CN110888684A - Process management method, terminal and computer readable storage medium - Google Patents
Process management method, terminal and computer readable storage medium Download PDFInfo
- Publication number
- CN110888684A CN110888684A CN201810950536.8A CN201810950536A CN110888684A CN 110888684 A CN110888684 A CN 110888684A CN 201810950536 A CN201810950536 A CN 201810950536A CN 110888684 A CN110888684 A CN 110888684A
- Authority
- CN
- China
- Prior art keywords
- application
- public
- running
- component
- priority
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/485—Task life-cycle, e.g. stopping, restarting, resuming execution
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a process management method, a terminal and a computer readable storage medium, and belongs to the technical field of terminals. The method comprises the following steps: after the system service is started, creating an empty public process and initializing the state of the public process; and when the application component is cold-started in a low memory state, loading and running the application component in the public process. According to the invention, the application component is operated in the public process without creating a new process when the application component is cold-started in the low-memory state, so that the application starting speed can be increased, the system memory can be saved, the terminal blockage caused by entering a vicious circle of killing and creating the process can be avoided, and the performance of the system in the low-memory state can be improved.
Description
Technical Field
The present invention relates to the field of terminal technologies, and in particular, to a process management method, a terminal, and a computer-readable storage medium.
Background
The functions of the terminal are more and more abundant, but for the low-configuration terminal, the functions increase the consumption of the system memory, and the use amount of the boot memory in a factory state is too high. The low-configuration terminal has the problem of unsmooth system blockage, and the main reason for blockage is that the system configuration is low and the memory is relatively tense.
The existing technical schemes mainly include three types:
(1) and identifying the background process for killing by counting the running data of the application process and the priority of the application by the background.
(2) Application processes needing to be created in advance are predicted through application information and use frequency, and application starting speed is accelerated.
(3) The process priority is dynamically adjusted by counting the application process running information to ensure that the foreground process runs and the background process is killed when the memory is low.
However, in the low memory state, some memory is released by killing the background process, but the cleaned application is called again in the running process of the application, so that the process is created again and enters a vicious circle. Frequent creation of processes not only affects the cold start time of an application, but also causes excessive overhead and indirectly causes other applications to slow down in response. The pre-created process can speed up the application cold start time, but the creation overhead of the process is relatively large, and the more pre-created processes, the greater the memory consumption. In low memory states, it is almost impossible to pre-create processes, which would otherwise result in memory exhaustion.
Thus, the system frequently cleans up background application processes, but these applications are again started by other applications. The system falls into a vicious circle of cleaning a background process- > creating a process- > cleaning the process, so that the application cold starting speed is low in a low memory state, the system overhead is too large, other application responses are caused to be slow indirectly, and the system is stuck.
Disclosure of Invention
In view of the above, embodiments of the present invention provide a process management method, a terminal and a computer readable storage medium to solve the technical problem of deadlock caused by a terminal entering a vicious circle for killing a process and creating a process when the terminal is in a low memory state.
The technical scheme adopted by the embodiment of the invention for solving the technical problems is as follows:
according to an aspect of an embodiment of the present invention, there is provided a process management method, including:
after the system service is started, creating an empty public process and initializing the state of the public process;
and when the application component is cold-started in a low memory state, loading and running the application component in the public process.
According to another aspect of the embodiments of the present invention, there is provided a terminal, which includes a memory, a processor, and a computer program stored in the memory and capable of running on the processor, and when the computer program is executed by the processor, the steps of the process management method are implemented.
According to still another aspect of embodiments of the present invention, there is provided a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of the process management method described above.
According to the process management method, the terminal and the computer readable storage medium provided by the embodiment of the invention, the application component is operated in the public process without creating a new process when the application component is cold-started in the low-memory state, so that the application starting speed can be increased, the system memory can be saved, the terminal is prevented from being blocked due to entering a vicious circle of killing the process and creating the process, and the performance of the system in the low-memory state is improved.
Drawings
Fig. 1 is a flowchart of a process management method according to an embodiment of the present invention;
fig. 2 is a flowchart of a method for initializing a common process state according to an embodiment of the present invention;
FIG. 3 is a diagram illustrating a data structure of a shared process according to an embodiment of the present invention;
fig. 4 is a flowchart of an application component permission checking method according to a second embodiment of the present invention;
fig. 5 is a flowchart of an application queue priority updating method according to a third embodiment of the present invention;
fig. 6 is a flowchart of a method for releasing a memory in a low memory state according to a fourth embodiment of the present invention;
fig. 7 is a flowchart of another process management method according to a fifth embodiment of the present invention;
fig. 8 is a block diagram of a process management method according to a sixth embodiment of the present invention.
The implementation, functional features and advantages of the objects of the present invention will be further explained with reference to the accompanying drawings.
Detailed Description
In order to make the technical problems, technical solutions and advantageous effects to be solved by the present invention clearer and clearer, the present invention is further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
Example one
As shown in fig. 1, a process management method provided in an embodiment of the present invention includes:
s101, after the system service is started, an empty public process is created, and the state of the public process is initialized.
Specifically, after the system is started, the system service process starts various system service components, and after the system service is started, an empty public process is created, and the state of the public process is initialized.
Referring to FIG. 2, initializing the state of the common process further comprises:
s201, setting the priority of a public process to be equal to the priority of a system service process;
s202, setting the security context of the public process as an untrusted application type;
s203, initializing an application package name list, an application priority queue and a process information structure which run in the common process.
Specifically, the priority of the public process is set to be equal to the priority of the system service process to ensure that the public process is not killed. And setting the security context of the public process as an untrusted application type so as to ensure that the security authority of the public process is the same as that of the common third-party application. The application package name list is used to store application package names that run in a common process. The application priority queue is used to identify a priority order of applications. The process information structure is used for storing a process identifier (used for identifying the common process, which can be a process number), a special user identifier (used for identifying the user authority of the common process) and a main thread object client agent of the common process, and the main thread object client agent is used for controlling the common process to load and run a corresponding application component.
S102, when the application component is cold started in a low memory state, the application component is loaded and operated in a public process.
Specifically, the cold start of the application component refers to that the application program to which the application component belongs is run for the first time or the application program to which the application component belongs is run for the first time after the application is destroyed. In the embodiment of the invention, when the application component is cold-started in a low-memory state, a new process is not created, and the application component is loaded and run in a common process. This step S102 further includes: and adding the application package name of the application program to which the application component belongs into the application package name list, thereby dynamically writing the application package name list, so that other components of the application program can be directly started in a public process when the other components of the application program are subsequently and thermally started. And acquiring a main thread object client agent from the process information structure, calling a main thread object client agent interface to notify a public process, and executing loading and running the application component after the public process receives the command.
Taking an Android terminal as an example, after the system is started, a system service process is started after the system is started, the system service starts various system services, and after all the services are started, a system ready state is entered, and an empty application process is created. The onSystemReady of each system service is then called back to perform the initialization action. The process priority is set equal to the system _ server process priority to ensure that the common process is not killed. And setting the second as an unregusted _ app to ensure that the selinux authority of the process is consistent with the authority of the common third-party application. The UID (user identification) of the public process may be named app _ common, and this private UID is not used by other processes. Referring to the data structure diagram of the common process shown in fig. 3, the list of application package names of the common process can be expressed as com. Xxx, …, com.yyy, the head to tail of the application priority queue are prioritized. The process information structure includes a PID (process identification), UID (user identification) and iapplatiationthread (main thread object client agent). And after the public process is started, a java virtual machine is operated, and the main thread executes ActivityThread. ActivityThread passes the client agent to the application manager and then enters a loop waiting for the application manager's onSchedulexxxx command to load the application component and run.
In the embodiment of the invention, the application component is operated in the public process without creating a new process when the application component is cold-started in the low-memory state, so that the application starting speed can be improved, the system memory is saved, the terminal jamming caused by entering a vicious circle of creating the process > killing the process > creating the process is avoided, and the performance of the system in the low-memory state is improved.
Example two
As shown in fig. 4, an authority verification method provided in an embodiment of the present invention includes:
s401, calling an API by an application component;
specifically, the Application component calls a system API (Application Programming Interface), and the calling mode includes acquiring an Interface schedule command called by a main thread object client agent to notify the public process to load and start the Application component. And after receiving the schedule command, the public process executes loading and runs the application component.
S402, the API acquires the user identification of the current process of the caller;
s403, judging whether the user identifier is a special user identifier of the public process, if so, executing a step S404, otherwise, executing a step S405;
s404, acquiring a user identifier of an application to which the currently running component belongs, performing permission verification according to the user identifier of the application to which the currently running component belongs, and turning to the step S406;
specifically, an application package name of an application to which an application component (caller) belongs is acquired, a user identifier of the application is acquired according to the application package name of the application to which the application component (caller) belongs, and the user identifier of the application is transmitted to the permission verification process. Such as: the UID of the current process is obtained, if the current process is the app _ common dedicated to the public process, the UID of the application to which the current running component belongs is obtained, the UID of the application is used for replacing the app _ common to perform authority check, and therefore the authority of each application running in the public process is independent.
S405, authority verification is carried out according to the user identification of the current process
And S406, ending the authority verification.
In the embodiment of the invention, when the system checks the authority of the application component in the public process, the user identifier of the current process is firstly obtained, if the user identifier is the special user identifier of the public process, the user identifier of the application to which the current running component belongs is obtained, and the special user identifier of the public process is replaced by the user identifier of the application to carry out authority verification, so that the authority of each application running in the public process is independent.
EXAMPLE III
As shown in fig. 5, a method for updating an application priority queue according to an embodiment of the present invention includes:
s501, running an application component in a public process;
s502, judging whether the application to which the current running component belongs becomes the foreground, if so, executing a step S503, otherwise, executing a step S504;
s503, directly moving the application of the current running component to the head of the application priority queue, and turning to the step S505;
s504, starting to search a first non-foreground application from the head of the priority queue, and moving the application of the current running component to the front of the first non-foreground application;
and S505, finishing updating the application priority queue.
Specifically, in an application priority queue in the common process, the application priority queue is sorted according to the use frequency of the application, the head is the most recently used foreground application, and the tail is the latest and least recently used background process. The position of the application in the application priority queue needs to be readjusted every time when the application component in the public process runs, so that the application at the head of the application priority queue is ensured to be a foreground application or a recently run application, the tail of the queue is a background application which is not used for the longest time at present, and when the memory space needs to be released, the background application with the lowest priority is preferentially cleaned.
It should be noted that, in this embodiment, the head of the queue indicates the level with the highest priority, and the tail of the queue indicates the level with the lowest priority, which is merely an illustration and is not a limitation to this embodiment. In practical implementation, the head of the queue can be used to indicate the lowest priority level, and the tail of the queue can be used to indicate the highest priority level.
In the embodiment of the invention, when the running of the application component causes the belonging application to become the foreground application, the priority of the belonging application is adjusted to the highest level; when the operation of the application component does not cause the application to become the foreground application, the priority of the application is adjusted to be the highest level in the non-foreground application, so that the application priority queue of the public process is dynamically updated, the application is cleared from low to high according to the priority to release the memory space when the memory is insufficient, and the performance of the system in the low memory state is further improved. .
Example four
As shown in fig. 6, an embodiment of the present invention provides a method for releasing a memory in a low memory state, where the method includes:
s601, monitoring the memory state of the system.
S602, judging whether the memory needs to be released, if so, executing the step S603, otherwise, returning to the step S601.
S603, inquiring an application priority queue of the public process to obtain an application with the lowest priority;
s604, judging whether the application with the lowest priority is a background application, if so, executing a step S605, otherwise, executing a step S606;
s605, destroying all the application components of the application with the lowest priority, removing the application with the lowest priority from the priority queue, removing the application package name with the lowest priority from the application package name list, and going to the step S607.
And S606, killing some processes according to the traditional process strategy.
S607, judging whether the memory requirement is met, if yes, turning to the step S608, otherwise, returning to the step S603;
and S608, finishing releasing the memory.
In the embodiment of the invention, in a low memory state, when the memory space needs to be released, the space occupied by the background application which is not used for the longest time in the public process is released, the applications are selected from the common process according to the sequence from low priority to high priority, and if the selected applications are the background applications, all application components of the applications are destroyed. When all background applications of the public process are cleaned up and the memory still needs to be released, namely the memory of the system is insufficient and the memory needs to be released, a traditional process strategy is adopted to kill some process release resources, and the performance of the system in a low-memory state is improved.
EXAMPLE five
As shown in fig. 7, an embodiment of the present invention provides another common process management method, where the method includes:
s701, after the system service is started, an empty public process is created, and the state of the public process is initialized.
S702, monitoring the memory state of the system.
And S703, judging whether the low memory state is entered, if so, executing the step S704, otherwise, returning to the step S702.
S704, waiting for the client request, executing the main thread according to the client request, starting the corresponding component, and performing permission verification on the application.
S705, dynamically updating the application priority queue.
Specifically, when the running of the application component causes the belonging application to become the foreground application, the priority of the belonging application is adjusted to the highest level; and when the running of the application component does not cause the belonging application to become the foreground application, adjusting the priority of the belonging application to be the highest level in the non-foreground application.
S706, judging whether the memory needs to be released, if so, executing step S707, otherwise, returning to step S704.
And S707, destroying the application components corresponding to the background application from the public process according to the sequence of the priority levels from low to high.
S708, judging whether to exit the low memory state, if so, executing step S709, otherwise, returning to step S704.
S709, when no foreground application exists in the public process, directly restarting the public process; when foreground application exists, restarting the public process after the foreground application enters a background;
s710, initializing the state of the common process, and returning to the step S701.
In the embodiment of the present invention, on the basis of the first to fourth embodiments, after exiting the low memory state, whether a foreground application exists in the public process is queried, and if the foreground application does not exist, the public process is directly restarted; if the foreground application exists, restarting the public process after the foreground application enters the background; and initializing the data structure of the public process to prepare for entering the low memory state next time, and then enabling the application to normally run and not run in the public process until entering the low memory state next time.
EXAMPLE six
As shown in fig. 8, an embodiment of the present invention provides a common process management apparatus, including:
the application manager 10 is configured to create an empty common process after the system service is started, and initialize a state of the common process;
specifically, the application manager 10, after the system service is started, creates an empty public process, and sets the priority of the public process equal to the priority of the system service process to ensure that the public process is not killed. Setting the security context of the public process as an untrusted application type to ensure that the security authority of the public process is the same as that of the common third-party application; initializing a list of application package names, a process information structure, and an application priority queue running in a common process. Wherein the application package name list is used for storing the application package names running in the common process. The application priority queue is used to store the priority order of the applications running in the common process. The process information structure is used for storing the process identification, the special user identification and the main thread object client agent of the public process, so that the process is identified and communicated with the public process, and the public process is controlled to load and operate the corresponding application component.
The common process manager 101 is configured to load and run the application component in the common process when the application component is cold-started in a low memory state.
Specifically, when the application component is cold-started in a low memory state, the common process manager 101 queries whether the application package name to which the application component belongs is included in the application package name list, and if not, adds the application package name to which the application component belongs to the application package name list. And acquiring a main thread object client agent from the process information structure, and calling a main thread object client agent interface to inform the public process to load and operate the application component.
In some embodiments, the apparatus may further comprise:
an application program interface 20, configured to obtain a user identifier of a current process, and if the user identifier is a dedicated user identifier of the public process, obtain a user identifier of an application to which a currently running component belongs; and transmitting the user identification of the application to which the current running component belongs to the application package manager 30 for permission verification, otherwise, transmitting the user identification of the current process to the application package manager 30 for permission verification.
And the application package manager 30 is used for performing authority verification on the application and authorizing the application.
In the embodiment of the present invention, the common process manager 101 is implemented as a module of the application manager 10, and is invoked to execute in the starting phase and the starting application component of the application manager 10. The common process manager 101 may be implemented independently as a system service, or may be implemented in addition to any other system service or component, and its functionality may be unchanged. The calling relationship and application program interface 20 for loading a plurality of different application components in a common process can be changed, and finally, each component of different applications can run in the common process.
EXAMPLE seven
The embodiment of the invention provides a terminal, which comprises a memory, a processor and a computer program which is stored on the memory and can run on the processor, wherein when the computer program is executed by the processor, the steps of the process management method are realized.
In addition, an embodiment of the present invention further provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the steps of the process management method are implemented.
It should be noted that the terminal and the computer-readable storage medium belong to the same concept as the embodiment of the process management method, and specific implementation processes thereof are detailed in the embodiment of the method, and technical features in the embodiment of the method are applicable to both the network device and the computer-readable storage medium, which are not described herein again.
It will be understood by those of ordinary skill in the art that all or some of the steps of the methods, systems, functional modules/units in the devices disclosed above may be implemented as software, firmware, hardware, and suitable combinations thereof.
In a hardware implementation, the division between functional modules/units mentioned in the above description does not necessarily correspond to the division of physical components; for example, one physical component may have multiple functions, or one function or step may be performed by several physical components in cooperation. Some or all of the physical components may be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application specific integrated circuit. Such software may be distributed on computer readable media, which may include computer storage media (or non-transitory media) and communication media (or transitory media). The term computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data, as is well known to those of ordinary skill in the art. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, Digital Versatile Disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by a computer. In addition, communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media as known to those skilled in the art.
The preferred embodiments of the present invention have been described above with reference to the accompanying drawings, and are not to be construed as limiting the scope of the invention. Any modifications, equivalents and improvements which may occur to those skilled in the art without departing from the scope and spirit of the present invention are intended to be within the scope of the claims.
Claims (10)
1. A method for process management, the method comprising:
after the system service is started, creating an empty public process and initializing the state of the public process;
and when the application component is cold-started in a low memory state, loading and running the application component in the public process.
2. The process management method according to claim 1, wherein the initializing the state of the common process specifically comprises:
setting the priority of the public process to be equal to the priority of a system service process;
setting the security context of the public process as an untrusted application type;
initializing a list of application package names, a process information structure, and an application priority queue running in the common process.
3. The process management method according to claim 2,
the application package name list is used for storing the application package names running in the public process;
the process information structure is used for storing the process identification, the special user identification and the main thread object client agent of the public process;
and the application priority queue is used for storing the priority sequence of the application to which the application component running in the common process belongs.
4. The process management method according to claim 2, wherein the loading and running the application component in the common process specifically comprises:
adding the application package name to which the application component belongs to the application package name list;
and acquiring a main thread object client agent from a process information structure, and calling the main thread object client agent interface to inform the public process to load and run the application component.
5. The process management method according to claim 1, wherein: after the application component is loaded and run in the common process, the method further comprises:
acquiring a user identifier of a current process, and acquiring a user identifier of an application to which a current running component belongs if the user identifier is a special user identifier of the public process;
and performing permission verification according to the user identification of the application to which the current running component belongs.
6. The process management method according to claim 1, wherein: in the process of loading and running the application component in the common process, the method further comprises the following steps:
when the running of the application component causes the application to become the foreground application, the priority of the application is adjusted to the highest level;
and when the running of the application component does not cause the belonging application to become a foreground application, adjusting the priority of the belonging application to be the highest level in the non-foreground application.
7. The process management method according to claim 2, wherein, in the process of loading and running the application component in the common process, the method further comprises:
and when the memory needs to be released, selecting applications from the common process according to the sequence of the priority from low to high, and destroying all application components of the applications if the selected applications are background applications.
8. The process management method according to any one of claims 1 to 7, wherein after the application component is loaded and run in the common process, the method further comprises:
after exiting the low memory state, inquiring whether foreground application exists in the public process, and if the foreground application does not exist, directly restarting the public process; if the foreground application exists, restarting the public process after the foreground application enters a background; and initializes the state of the common process.
9. A terminal, characterized in that it comprises a memory, a processor and a computer program stored on said memory and executable on said processor, said computer program, when executed by said processor, implementing the steps of the process management method according to any one of claims 1 to 8.
10. A computer-readable storage medium, characterized in that a computer program is stored on the computer-readable storage medium, which computer program, when being executed by a processor, carries out the steps of the process management method according to one of claims 1 to 8.
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810950536.8A CN110888684A (en) | 2018-08-20 | 2018-08-20 | Process management method, terminal and computer readable storage medium |
| PCT/CN2019/090993 WO2020038084A1 (en) | 2018-08-20 | 2019-06-12 | Process management method, terminal and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201810950536.8A CN110888684A (en) | 2018-08-20 | 2018-08-20 | Process management method, terminal and computer readable storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN110888684A true CN110888684A (en) | 2020-03-17 |
Family
ID=69592218
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201810950536.8A Pending CN110888684A (en) | 2018-08-20 | 2018-08-20 | Process management method, terminal and computer readable storage medium |
Country Status (2)
| Country | Link |
|---|---|
| CN (1) | CN110888684A (en) |
| WO (1) | WO2020038084A1 (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104750555A (en) * | 2015-03-31 | 2015-07-01 | 北京奇虎科技有限公司 | Management method and device for progresses in Android program |
| CN107608785A (en) * | 2017-08-15 | 2018-01-19 | 深圳天珑无线科技有限公司 | Process management method, mobile terminal and readable storage medium |
| CN107896273A (en) * | 2017-09-28 | 2018-04-10 | 努比亚技术有限公司 | A kind of terminal processes management method, terminal and computer-readable recording medium |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106484472B (en) * | 2016-09-29 | 2021-06-15 | 华为技术有限公司 | Memory recovery method and terminal |
| CN107944257A (en) * | 2017-11-21 | 2018-04-20 | 广东欧珀移动通信有限公司 | Start control method, device, storage medium and the terminal of application with method of service |
| CN108196892B (en) * | 2017-12-29 | 2021-02-23 | 北京安云世纪科技有限公司 | Method and device for customizing system starting process and mobile terminal |
-
2018
- 2018-08-20 CN CN201810950536.8A patent/CN110888684A/en active Pending
-
2019
- 2019-06-12 WO PCT/CN2019/090993 patent/WO2020038084A1/en active Application Filing
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104750555A (en) * | 2015-03-31 | 2015-07-01 | 北京奇虎科技有限公司 | Management method and device for progresses in Android program |
| CN107608785A (en) * | 2017-08-15 | 2018-01-19 | 深圳天珑无线科技有限公司 | Process management method, mobile terminal and readable storage medium |
| CN107896273A (en) * | 2017-09-28 | 2018-04-10 | 努比亚技术有限公司 | A kind of terminal processes management method, terminal and computer-readable recording medium |
Also Published As
| Publication number | Publication date |
|---|---|
| WO2020038084A1 (en) | 2020-02-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110753131A (en) | Microservice distributed current limiting method and device, storage medium and electronic equipment | |
| CN113037794B (en) | Method, device and system for computing resource allocation scheduling | |
| US10560385B2 (en) | Method and system for controlling network data traffic in a hierarchical system | |
| JP2017152026A (en) | Method and device for updating clients | |
| US20190317824A1 (en) | Deployment of services across clusters of nodes | |
| CN110673927B (en) | Scheduling method and device of virtual machine | |
| CN111290838B (en) | Application access request processing method and device based on container cluster | |
| CN111385296B (en) | Business process restarting method, device, storage medium and system | |
| CN112948050A (en) | Method and device for deploying pod | |
| CN112860387A (en) | Distributed task scheduling method and device, computer equipment and storage medium | |
| CN113360893B (en) | Container-based intelligent contract execution method and device and storage medium | |
| CN106155790B (en) | Application program management method and device and terminal | |
| CN107463390B (en) | Software upgrading method and upgrading server | |
| CN110795234A (en) | Resource scheduling method and device | |
| US20220206836A1 (en) | Method and Apparatus for Processing Virtual Machine Migration, Method and Apparatus for Generating Virtual Machine Migration Strategy, Device and Storage Medium | |
| CN114691547B (en) | Method for deploying instance, instance management node, computing node and computing device | |
| CN112804276B (en) | Virtual broadband remote access server, control method thereof and communication system | |
| CN110888684A (en) | Process management method, terminal and computer readable storage medium | |
| CN111225007B (en) | Database connection method, device and system | |
| EP3389222A1 (en) | A method and a host for managing events in a network that adapts event-driven programming framework | |
| CN113886082A (en) | Request processing method and device, computing equipment and medium | |
| CN113986458A (en) | Container set scheduling method, device, equipment and storage medium | |
| CN114077493A (en) | Resource allocation method and related equipment | |
| CN112231057A (en) | Information processing method, device and system | |
| CN110380894A (en) | The management method and device of cloud platform medium cloud host |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |