Application background service management method and device, equipment and storage medium

Abstract

The application relates to the technical field of software, and discloses an application background service management method, device, equipment and storage medium, the method comprises the following steps: acquiring the current state of a thread pool when an interactive page exits; acquiring the identification information and class name of the thread pool when the current state is a target state; determining application background service data according to the identification information and class name of the thread pool; and managing the service of the application background according to the application background service data. Through the above method, when the current state of the thread pool is determined to be the target state when the interactive page exits, the application background service data is determined according to the identification information and class name of the thread pool, and then the service of the application background is managed based on the application background service data, so that the accuracy of managing the application background service can be effectively improved, and the background can be operated for a long time and the operation on the thread created by the component can be executed.

Description

Technical Field

[0001] This invention relates to the field of software technology, and in particular to application backend service management methods, apparatus, devices, and storage media. Background Technology

[0002] In Android application development, the management of background services is often indispensable. As one of the application components provided by Android, Service has the characteristic of running in the background even when the user does not interact with the application. Service runs in the main thread of the managed process and does not create its own thread. If Service will perform any CPU-intensive or blocking operations, this work should be done by creating a child thread within Service. However, child threads cannot be controlled by Service's interactive components, broadcast receivers, or other services. This means that when the interactive component is destroyed, it is impossible to obtain a new instance of the child thread. Furthermore, a child thread created in one interactive component cannot be operated on by another interactive component. Ultimately, this leads to low accuracy in managing application background services and the inability to achieve long-term background operation and execution of operations on threads created by components.

[0003] The above content is only used to help understand the technical solution of the present invention and does not represent an admission that the above content is prior art. Summary of the Invention

[0004] The main objective of this invention is to provide an application background service management method, apparatus, device, and storage medium, which aims to solve the technical problems of low accuracy in managing application background services in the prior art, and the inability to achieve long-term background operation and execution of operations on threads created by components.

[0005] To achieve the above objectives, the present invention provides an application background service management method applied to the static area of ​​a memory model. The application background service management method includes the following steps:

[0006] Get the current state of the thread pool when the interactive page is exited;

[0007] When the current state is the target state, obtain the identification information and class name of the thread pool;

[0008] The application background service data is determined based on the thread pool's identification information and class name;

[0009] The application backend services are managed based on the application backend service data.

[0010] Optionally, obtaining the current state of the thread pool when the interactive page exits includes:

[0011] Once the application process is detected to have started, the interactive page will be displayed.

[0012] During the display process, a thread pool is started by the interactive component corresponding to the interactive page, and the thread pool is created and runs in the static area.

[0013] After the thread pool starts, multiple threads are created, and the current time-consuming task is processed by these multiple threads.

[0014] During processing, the current state of the thread pool is obtained when the interactive page exits.

[0015] Optionally, obtaining the current state of the thread pool when the interactive page exits during the processing includes:

[0016] During the processing, determine whether to launch other interactive components through the interactive component;

[0017] When it is determined that other interactive components are launched through an interactive component, the target interactive page corresponding to the other interactive component is displayed, and the interactive page is exited.

[0018] Obtain the current state of the thread pool when the interaction ends.

[0019] Optionally, after obtaining the current state of the thread pool when the interactive page exits, the method further includes:

[0020] When the current state is not the target state, the control application background service stops running.

[0021] Optionally, determining the application background service data based on the thread pool's identifier information and class name includes:

[0022] The application's backend settings service functions are determined by other interactive components based on the thread pool's identification information and class name.

[0023] The data generated by the function execution is determined based on the defined service function;

[0024] The application background service data is determined based on the data generated by the execution of the aforementioned function.

[0025] Optionally, after managing the application backend services based on the application backend service data, the method further includes:

[0026] Get the application's currently displayed page;

[0027] When the currently displayed page is an interactive page, the interactive component is activated through other interactive components, and the interactive page corresponding to the interactive component is displayed.

[0028] Optionally, after displaying the interactive page corresponding to the interactive component, the method further includes:

[0029] Identify and return to the currently running thread pool;

[0030] Obtain the identification information and class name of the currently running thread pool;

[0031] The application background service data is determined based on the identification information and class name of the running thread pool.

[0032] Furthermore, to achieve the above objectives, the present invention also proposes an application background service management device, the application background service management device comprising:

[0033] The retrieval module is used to retrieve the current state of the thread pool when the interactive page is exited.

[0034] The judgment module is used to obtain the identification information and class name of the thread pool when the current state is the target state;

[0035] The determination module is used to determine the application background service data based on the identification information and class name of the thread pool;

[0036] The management module is used to manage the services of the application backend based on the application backend service data.

[0037] In addition, to achieve the above objectives, the present invention also proposes an application background service management device, which includes: a memory, a processor, and an application background service management program stored on the memory and executable on the processor. The application background service management program is configured to implement the application background service management method described above.

[0038] In addition, to achieve the above objectives, the present invention also proposes a storage medium storing an application background service management program, which, when executed by a processor, implements the application background service management method as described above.

[0039] The application background service management method proposed in this invention obtains the current state of the thread pool when the interactive page exits; when the current state is the target state, it obtains the identification information and class name of the thread pool; it determines the application background service data based on the identification information and class name of the thread pool; and it manages the application background service based on the application background service data. Through this method, when the current state of the thread pool at the time of the interactive page exit is determined to be the target state, the application background service data is determined based on the identification information and class name of the thread pool, and then the application background service is managed based on the application background service data. This effectively improves the accuracy of managing application background services, thereby enabling long-term background operation and execution of operations on threads created by components. Attached Figure Description

[0040] Figure 1 This is a schematic diagram of the structure of the application background service management device of the hardware operating environment involved in the embodiments of the present invention;

[0041] Figure 2 This is a flowchart illustrating the first embodiment of the background service management method of the present invention.

[0042] Figure 3 This is a schematic diagram of the structure of a JAVA memory model according to an embodiment of the background service management method of the present invention;

[0043] Figure 4 This is a flowchart illustrating the second embodiment of the background service management method of the present invention.

[0044] Figure 5 This is a schematic diagram of the overall process of an embodiment of the background service management method of the present invention;

[0045] Figure 6 This is a schematic diagram of the functional modules of the first embodiment of the background service management device of the present invention.

[0046] The realization of the objective, functional features and advantages of the present invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0047] It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0048] Reference Figure 1 , Figure 1 This is a schematic diagram of the application background service management device structure of the hardware operating environment involved in the embodiments of the present invention.

[0049] like Figure 1As shown, the application background service management device may include: a processor 1001, such as a central processing unit (CPU), a communication bus 1002, a user interface 1003, a network interface 1004, and a memory 1005. The communication bus 1002 is used to enable communication between these components. The user interface 1003 may include a display screen or an input unit such as a keyboard; optionally, the user interface 1003 may also include a standard wired interface or a wireless interface. The network interface 1004 may optionally include a standard wired interface or a wireless interface (such as a Wireless-Fidelity (Wi-Fi) interface). The memory 1005 may be a high-speed random access memory (RAM) or a stable non-volatile memory (NVM), such as a disk drive. The memory 1005 may also optionally be a storage device independent of the aforementioned processor 1001.

[0050] Those skilled in the art will understand that Figure 1 The structure shown does not constitute a limitation on the application backend service management device and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0051] like Figure 1 As shown, the memory 1005, which serves as a storage medium, may include an operating system, a network communication module, a user interface module, and an application background service management program.

[0052] exist Figure 1 In the application background service management device shown, the network interface 1004 is mainly used for data communication with the network integrated platform workstation; the user interface 1003 is mainly used for data interaction with the user; the processor 1001 and memory 1005 in the application background service management device of the present invention can be set in the application background service management device, and the application background service management device calls the application background service management program stored in the memory 1005 through the processor 1001 and executes the application background service management method provided in the embodiment of the present invention.

[0053] Based on the above hardware structure, an embodiment of the application background service management method of the present invention is proposed.

[0054] Reference Figure 2 , Figure 2 This is a flowchart illustrating the first embodiment of the background service management method of the present invention.

[0055] In the first embodiment, the application backend service management method includes the following steps:

[0056] Step S10: Obtain the current state of the thread pool when the interactive page exits.

[0057] It should be noted that the execution subject in this embodiment is the application background service management device, but it can also be other devices that can achieve the same or similar functions, such as background service controllers. This embodiment does not limit this, and in this embodiment, the background service controller will be used as an example for explanation.

[0058] It is understandable that the current state refers to the state of the thread pool when the interactive page exits. This current state includes the open state and the closed state. The thread pool can execute multiple consumable tasks, that is, it can repeatedly call existing threads in the thread pool. Since the threads in the thread pool do not need to be created before each use, the threads can remain in a running state without being affected by the state of the object that created the thread. Therefore, regardless of whether the object that created the thread is in the initial state or the restarted state, the thread content can be retrieved again.

[0059] It should be noted that the memory model used in this embodiment can be the Java memory model, see reference. Figure 3 , Figure 3 This is a structural diagram of the Java memory model, including: the Java heap, the Java stack, and the static area. The Java heap stores created object instances and is created when the virtual machine starts, and is shared by all threads. The Java stack mainly contains the Java Virtual Machine stack and the native method stack, both of which are thread-private and cannot be shared between other threads. The static area, also known as the method area, is shared by all threads and stores static members, which are elements that are unique throughout the entire application. Because the solution in this embodiment applies to the static area of ​​the Java memory model, threads created based on the thread pool can avoid their lifecycle being bound to the object that created them, thus allowing the threads to work independently of their parent thread. Once the thread pool is created and running, it can be directly accessed by any object by its class name.

[0060] Further, step S10 includes: after detecting the start of the application process, displaying the interactive page; during the display process, starting a thread pool through the interactive component corresponding to the interactive page, wherein the thread pool is created and runs in the static area; after the thread pool is started, creating multiple threads and processing the current time-consuming task through the multiple threads; during the processing, obtaining the current state of the thread pool when the interactive page exits.

[0061] It should be understood that after the application process is detected to have started, the interactive page is displayed. This interactive page can be Activity A. During the display of the interactive page, a thread pool is started through the interactive component corresponding to the interactive page. This interactive component can be Activity A. The currently time-consuming task refers to the task that is running and consuming resources and time. There can be multiple such currently time-consuming tasks. After the thread pool starts, multiple threads are created. This creation process includes: initializing thread pool parameters, creating core threads, and creating a waiting queue. The thread pool parameters include, but are not limited to, thread pool size, number of core threads, maximum number of threads, and waiting queue size.

[0062] Understandably, after creating multiple threads, these threads are used to process the current time-consuming task. During processing, it is determined whether to exit the interactive page. If so, the current state of the thread pool is obtained. Exiting the interactive page means that other interactive pages need to be displayed. For example, other interactive components are launched through interactive components, and then the display of the interactive page is exited, and the interactive page corresponding to the other delivery component is displayed. For example, the interactive component can be Activity A, the other interactive component can be Activity B, the interactive page can be Activity A, and the target interactive page corresponding to the other interactive component can be Activity B.

[0063] Furthermore, the step of obtaining the current state of the thread pool when the interactive page exits during the processing includes: determining whether to launch other interactive components through the interactive component during the processing; if it is determined that other interactive components are launched through the interactive component, displaying the target interactive page corresponding to the other interactive component, and controlling the interactive page to exit; and obtaining the current state of the thread pool when the interaction exits.

[0064] Understandably, during the processing, it is determined whether other interactive components are launched through the interactive component, i.e., whether the Activity B component is launched. If so, the interactive page is exited, and the target interactive page corresponding to other interactive components, i.e., the Activity B page, is displayed. Then, the current state of the thread pool at the current moment is obtained.

[0065] Furthermore, after step S10, the method further includes: when the current state is not the target state, controlling the application background service to stop running.

[0066] It should be understood that the target state can be an on state. When the current state is not the target state, it indicates that the thread pool is shut down when the interactive page is exited. At this time, the background service of the control application stops running, that is, it no longer processes the consuming tasks.

[0067] Step S20: When the current state is the target state, obtain the identification information and class name of the thread pool.

[0068] It is understandable that when the current state is determined to be the target state, it means that the thread pool was not shut down when the interactive page exited, and the threads in the thread pool continued to run, that is, the background service continued to run. At this time, the identification information and class name of the thread pool are obtained, and the identification information can be the name of the thread pool.

[0069] Step S30: Determine the application background service data based on the thread pool's identification information and class name.

[0070] It should be understood that application background service data refers to the data processed by the application background service, which is determined by other interactive components that are started through the thread pool's identification information and class name.

[0071] Further, step S30 includes: determining the application background setting service function based on the thread pool's identification information and class name through other interactive components; determining the data generated by the function execution based on the setting service function; and determining the application background service data based on the data generated by the function execution.

[0072] It is understandable that setting up a service function refers to a function that is pre-set in the application background. This setting up service function can be determined based on the thread pool's identification information and class name. For example, this setting up service function can be counting, playing videos, etc. Then, the setting up service function is executed to determine the data generated by the function execution. Then, the application background service data is determined based on the data generated by the function execution, thereby realizing the binding of non-startup background service functions.

[0073] Step S40: Manage the application backend services based on the application backend service data.

[0074] Understandably, after determining the application backend service data, the application backend services are managed based on this data, such as adding, deleting, modifying, and querying application backend service functions, and optimizing the performance of application backend services.

[0075] This embodiment obtains the current state of the thread pool when the interactive page exits; when the current state is the target state, it obtains the identification information and class name of the thread pool; it determines the application background service data based on the identification information and class name of the thread pool; and it manages the application background services based on the application background service data. Through this method, when the current state of the thread pool is determined to be the target state when the interactive page exits, the application background service data is determined based on the identification information and class name of the thread pool, and then the application background services are managed based on the application background service data. This effectively improves the accuracy of managing application background services, thereby enabling long-term background operation and execution of operations on threads created by components.

[0076] In one embodiment, such as Figure 4 The second embodiment of the application background service management method of the present invention, based on the first embodiment, further includes the following after step S40:

[0077] Step S501: Obtain the current display page of the application.

[0078] It should be understood that the currently displayed page refers to the page displayed by the application at the current moment. The currently displayed page may include interactive pages, target interactive pages corresponding to other interactive components, etc., such as Activity A page and Activity B page.

[0079] Step S502: When the currently displayed page is an interactive page, the interactive component is activated through other interactive components, and the interactive page corresponding to the interactive component is displayed.

[0080] Understandably, when it is determined that the currently displayed page is an interactive page, it means that the application's display page has switched from the target interactive page to the interactive page. At this time, the interactive component is launched through other interactive components, that is, Activity A is launched using Activity B, and the interactive page corresponding to the interactive component is displayed, and the Activity B page corresponding to Activity B is exited.

[0081] Furthermore, after step S502, the method further includes: identifying and returning to the running thread pool; obtaining the identification information and class name of the running thread pool; and determining the application background service data based on the identification information and class name of the running thread pool.

[0082] It should be understood that after the application's display page switches back to the interactive page, Activity A will restart the thread pool. Since the created thread pool runs in the static area, it is necessary to maintain the uniqueness of the thread pool. Therefore, it will automatically return to the running thread pool to avoid recreating the thread pool. At the same time, it will maintain the current state of the application's background service, that is, identify and return to the running thread pool. Then, the interactive component will determine the application's background service data based on the identification information and class name of the running thread pool, thereby enabling the class that created the application's background service to obtain the application's background service again.

[0083] Understandably, reference Figure 5 , Figure 5 The overall process is illustrated below: After detecting application startup, an interactive page is displayed. Then, a thread pool is started through the interactive component corresponding to the interactive page. After startup, multiple threads are created and used to handle the current time-consuming task. When it is detected that other interactive components are started through the interactive component, the interactive page is exited, and the target interactive page corresponding to the other interactive component is displayed. Then, it is determined whether the current state of the thread pool at the time of interaction exit is the target state. If not, the application background service is stopped. If so, the threads in the thread pool continue to run. Then, the application background service data is determined through other interactive components based on the thread pool's identification information and class name. It is then determined whether the application's currently displayed page is an interactive page. If so, the interactive component is started through other interactive components, and the running thread pool is determined. Finally, the application background service data is determined through the interactive component based on the running thread pool's identification information and class name.

[0084] This embodiment obtains the currently displayed page of the application; when the currently displayed page is an interactive page, it starts the interactive component through other interactive components and displays the interactive page corresponding to the interactive component; through the above method, after obtaining the currently displayed page of the application, it determines whether the currently displayed page is an interactive page. If it is, it starts the interactive component through other interactive components and displays the interactive page corresponding to the interactive component, thereby effectively improving the accuracy of the displayed page and avoiding the need to recreate the thread pool.

[0085] Furthermore, this embodiment of the invention also proposes a storage medium storing an application background service management program, which, when executed by a processor, implements the steps of the application background service management method described above.

[0086] Since this storage medium adopts all the technical solutions of all the above embodiments, it has at least all the beneficial effects brought about by the technical solutions of the above embodiments, which will not be repeated here.

[0087] In addition, refer to Figure 6 This invention also proposes an application background service management device, which includes:

[0088] Module 10 is used to obtain the current state of the thread pool when the interactive page exits.

[0089] The judgment module 20 is used to obtain the identification information and class name of the thread pool when the current state is the target state.

[0090] The determination module 30 is used to determine the application background service data based on the identification information and class name of the thread pool.

[0091] The management module 40 is used to manage the services of the application backend based on the application backend service data.

[0092] This embodiment obtains the current state of the thread pool when the interactive page exits; when the current state is the target state, it obtains the identification information and class name of the thread pool; it determines the application background service data based on the identification information and class name of the thread pool; and it manages the application background services based on the application background service data. Through this method, when the current state of the thread pool is determined to be the target state when the interactive page exits, the application background service data is determined based on the identification information and class name of the thread pool, and then the application background services are managed based on the application background service data. This effectively improves the accuracy of managing application background services, thereby enabling long-term background operation and execution of operations on threads created by components.

[0093] It should be noted that the workflow described above is merely illustrative and does not limit the scope of protection of this invention. In practical applications, those skilled in the art can select some or all of the workflow to achieve the purpose of this embodiment according to actual needs, and no restrictions are imposed here.

[0094] In addition, for technical details not described in detail in this embodiment, please refer to the application background service management method provided in any embodiment of the present invention, which will not be repeated here.

[0095] In one embodiment, the acquisition module 10 is further configured to display an interactive page after detecting that the application process has started; during the display process, a thread pool is started through the interactive component corresponding to the interactive page, and the thread pool is created and runs in the static area; after the thread pool is started, multiple threads are created and the current time-consuming task is processed through the multiple threads; during the processing, the current state of the thread pool when the interactive page exits is obtained.

[0096] In one embodiment, the acquisition module 10 is further configured to determine, during the processing, whether to launch other interactive components through the interactive component; when it is determined that other interactive components are launched through the interactive component, to display the target interactive page corresponding to the other interactive component and to control the interactive page to exit; and to acquire the current state of the thread pool when the interaction exits.

[0097] In one embodiment, the acquisition module 10 is further configured to control the application background service to stop running when the current state is not the target state.

[0098] In one embodiment, the determining module 30 is further configured to determine the application background setting service function based on the thread pool's identification information and class name through other interactive components; determine the data generated by the function execution based on the setting service function; and determine the application background service data based on the data generated by the function execution.

[0099] In one embodiment, the management module 40 is further configured to obtain the current display page of the application; when the current display page is an interactive page, to activate the interactive component through other interactive components and display the interactive page corresponding to the interactive component.

[0100] In one embodiment, the management module 40 is further configured to identify and return to the running thread pool; obtain the identification information and class name of the running thread pool; and determine the application background service data based on the identification information and class name of the running thread pool.

[0101] Other embodiments or implementation methods of the application background service management device described in this invention can be referred to the above-described method embodiments, and will not be repeated here.

[0102] It should be understood that although the steps in the flowcharts of this application's embodiments are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some of the steps in the figures may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be performed alternately or in turn with other steps or at least a portion of the sub-steps or stages of other steps.

[0103] Furthermore, it should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or system. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or system that includes that element.

[0104] The sequence numbers of the above embodiments of the present invention are for descriptive purposes only and do not represent the superiority or inferiority of the embodiments.

[0105] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as read-only memory (ROM) / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal device (which may be a mobile phone, computer, all-in-one platform workstation, or network device, etc.) to execute the methods described in the various embodiments of the present invention.

[0106] The above are merely preferred embodiments of the present invention and do not limit the patent scope of the present invention. Any equivalent structural or procedural transformations made based on the content of the present invention's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of the present invention.

Claims

1. A method for managing application backend services, characterized in that, The application background service management method, applied to the static area of ​​the memory model, includes the following steps: Get the current state of the thread pool when the interactive page is exited; When the current state is the target state, obtain the identification information and class name of the thread pool; The application background service data is determined based on the thread pool's identification information and class name; The application backend services are managed based on the application backend service data. The process of obtaining the current state of the thread pool when the interactive page exits includes: Once the application process is detected to have started, the interactive page will be displayed. During the display process, a thread pool is started by the interactive component corresponding to the interactive page, and the thread pool is created and runs in the static area. After the thread pool starts, multiple threads are created, and the current time-consuming task is processed by these multiple threads. During processing, it is determined whether to launch other interactive components through the interactive component; if it is determined that other interactive components are launched through the interactive component, the target interactive page corresponding to the other interactive component is displayed, and the interactive page is controlled to exit; the current state of the thread pool is obtained when the interaction exits.

2. The application backend service management method as described in claim 1, characterized in that, After obtaining the current state of the thread pool when the interactive page exits, the method further includes: When the current state is not the target state, the control application background service stops running.

3. The application backend service management method as described in claim 1, characterized in that, The step of determining the application background service data based on the thread pool's identifier information and class name includes: The application's backend settings service functions are determined by other interactive components based on the thread pool's identification information and class name. The data generated by the function execution is determined based on the defined service function; The application background service data is determined based on the data generated by the execution of the aforementioned function.

4. The application backend service management method as described in any one of claims 1 to 3, characterized in that, After managing the application backend services based on the application backend service data, the method further includes: Get the application's currently displayed page; When the currently displayed page is an interactive page, the interactive component is activated through other interactive components, and the interactive page corresponding to the interactive component is displayed.

5. The application backend service management method as described in claim 4, characterized in that, After displaying the interactive page corresponding to the interactive component, the method further includes: Identify and return to the currently running thread pool; Obtain the identification information and class name of the currently running thread pool; The application background service data is determined based on the identification information and class name of the running thread pool.

6. An application backend service management device, characterized in that, The application backend service management device includes: The retrieval module is used to retrieve the current state of the thread pool when the interactive page is exited. The judgment module is used to obtain the identification information and class name of the thread pool when the current state is the target state; The determination module is used to determine the application background service data based on the identification information and class name of the thread pool; The management module is used to manage the application backend services based on the application backend service data. The acquisition module is further configured to display an interactive page after detecting the start of an application process; during the display process, a thread pool is started through the interactive component corresponding to the interactive page, and the thread pool is created and runs in the static area; after the thread pool is started, multiple threads are created, and the current time-consuming task is processed through the multiple threads; during the processing, it is determined whether to start other interactive components through the interactive component; when it is determined that other interactive components are started through the interactive component, the target interactive page corresponding to the other interactive component is displayed, and the interactive page is controlled to exit; and the current state of the thread pool is obtained when the interaction exits.

7. An application backend service management device, characterized in that, The application background service management device includes: a memory, a processor, and an application background service management program stored on the memory and capable of running on the processor. The application background service management program is configured to implement the application background service management method as described in any one of claims 1 to 5.

8. A storage medium, characterized in that, The storage medium stores an application background service management program, which, when executed by a processor, implements the application background service management method as described in any one of claims 1 to 5.

Images