WO2019036906A1

WO2019036906A1 - Android system-based low memory killer system and method

Info

Publication number: WO2019036906A1
Application number: PCT/CN2017/098520
Authority: WO
Inventors: 邓强
Original assignee: 深圳传音通讯有限公司
Priority date: 2017-08-22
Filing date: 2017-08-22
Publication date: 2019-02-28

Abstract

An Android system-based low memory killer system and method, said method comprising: S1. a memory detection module detecting, in real time, whether a memory space of an Android system reaches a set expected value; executing S2 when the expected value is not reached; S2. the low memory drive module screening, from all the currently running processes, out a process having the lowest priority; S3. a process management service module matching the process having the lowest priority with other currently running processes, and screening out associated processes correlated with the process having the lowest priority, so as to acquire a persistent process cluster; S4. a process killer module killing the persistent process cluster, freeing up a memory space occupied by these processes, and returning to execute S1. By screening out the associated processes to completely remove the correlated persistent process clusters, the invention can quickly and effectively recycle the memory space of the system, promptly solving the problem of the system getting stuck, effectively improving the user experience, and reducing the system power consumption.

Description

Low memory killing system and method based on Android system

Technical field

The invention relates to a system memory management mechanism of an intelligent mobile terminal, in particular to a low memory killing system and method based on an Android system.

Background technique

The Android (Android) system currently used in smart mobile terminals such as mobile phones is an open source operating system based on Linux system development. The memory management of Linux system has its unique dynamic storage management mechanism, but the Android system is further optimized based on the memory management mechanism of Linux. The Linux system will end the process after the process activity has stopped, and the Android system will keep these processes in memory.

Therefore, the Android system is a multi-tasking system, which means that multiple processes can be run simultaneously. In general, it takes a certain amount of time to start a process, so in order to speed up the process, whenever the user exits a process, the Android system does not immediately stop the process completely (commonly known as killing the process). So that when the user chooses to run the process next time, they can start quickly. However, as more and more processes are reserved in the Android system, the memory will definitely be insufficient. At this time, the Android system will start the automatic killing process of the process, which is the most used and the least important to use. The process (or according to the specified priority) to perform the killing operation, recovering the memory occupied by the corresponding process, to achieve the purpose of optimizing the system memory, and alleviating the problem of the system, and this function is called low memory killing (Low Memory) Killer, LMK) mechanism.

At present, the Android system has a total of six types of processes, and the possibility of being detected and stopped by the low memory killing mechanism is arranged from low to high, in order: foreground process, visible process, secondary process, background process, content provider And an empty process. That is to say, when the memory of the Android system is insufficient, the first process to be killed is an empty process (if it exists). If the empty process is still unable to guarantee enough memory space to maintain normal system operation after being killed, the second one will be the content provider. And so on, the next third will be the background process. However, in general, the front-end process, the visible process, and the secondary process are three types of processes in system memory management. In the process, the possibility of being killed by the low memory killing mechanism is very small, because once these processes are killed, it will result in a very poor user experience.

The Android system has a rule to reclaim the memory space. It has a predetermined threshold for the scheduling of the memory space. Only when the memory space of the system is lower than the threshold, the Android system will start the low memory killing mechanism. The default rule order is to stop running the system that is considered to be the least important process, thus freeing up memory space.

In the prior art, it is generally only necessary to open the following directory file of the smart mobile terminal using the Android system, that is, the directory file of Sys/Module/Lowmemorykiller/Parameters/Minfree, and the corresponding threshold is recorded therein. For example, when the running memory of the Android system is less than 211Mb, the low memory killing mechanism needs to kill the empty process; when the running memory of the Android system is less than 176Mb, the low memory killing mechanism not only needs to kill the empty process, but also needs to be combined. Kill the content provider.

However, at present, some application processes can reach the resident system through certain technical means, and cannot completely kill and kill, and the purpose of resurrection. And such processes have become more and more intensive, more and more, resulting in flooding, which greatly reduces the actual effect of low memory killing mechanism. Usually, the method of killing these stubborn processes is: when the process starts running, two or more processes will be started at the same time to form a process group associated with each other. When the low memory killing mechanism is triggered, after killing a process with the lowest priority, the other still-lived associated processes will re-run an alternate process, causing the low memory killing mechanism to try to kill the process (changing after the restart) For another alternative process, the expected effect of reclaiming the memory used by the corresponding process is not achieved.

As shown in FIG. 1 , it is a flowchart of the low memory killing mechanism in the prior art. When the Android system triggers the low memory killing mechanism to start due to insufficient memory, the specific killing process includes the following steps:

S1, traversing the list of all processes currently running;

S2: selecting, according to the set priority, a process with the lowest priority that meets the condition;

S3, killing the process, that is, causing the process to stop running, releasing the memory occupied by the process, so that the memory is updated;

S4. Determine whether the updated memory size satisfies the needs of the system operation; if yes, end the low memory killing mechanism; if not, return to S1 to continue the killing process.

In the existing technical solution, since the low memory killing mechanism is only a mechanical traversal process list, select one of them. The lowest priority process is checked and killed. After the completion, it is judged whether the currently available memory has reached the expected level. If the expected memory has not been reached, repeat the above steps until the available memory reaches the expected value. Therefore, it has the following defects:

1. Because there are many stubborn processes mentioned above in the system, after the killing, they will be restarted by their associated processes, and they cannot be completely cleaned up;

2, because the stubborn process can not be completely cleaned up, resulting in low memory killing mechanism will repeatedly kill the same process (or its replacement process), resulting in memory space can not be quickly released, making the system continue to jam;

3. Since the stubborn process cannot be completely cleaned up, the low memory killing mechanism will repeatedly kill the same process (or its replacement process), resulting in a problem of large power consumption of the intelligent mobile terminal, causing the power to drop rapidly;

4. The problem that smart mobile terminals are often stuck due to insufficient memory will result in a poor user experience, resulting in a decline in product reputation and affecting the long-term healthy development of the company.

Based on the above, it is urgent to propose a new low-memory killing system and method based on Android system, which can effectively enhance the process killing effect under low memory conditions, completely kill stubborn processes with associated processes, and improve the efficiency of killing. , quickly release system memory.

Disclosure of invention

The object of the present invention is to provide a low memory killing system and method based on the Android system, which can quickly and effectively recover the system memory space by troubleshooting the associated process to completely remove the stubborn process cluster with correlation, so that the system can get the problem of the card. Timely mitigation, effectively improving the user experience and reducing system power consumption.

To achieve the above object, the present invention provides a low memory killing system based on an Android system, comprising: a memory detecting module, detecting in real time whether the memory space of the Android system reaches a set expected value; a low memory driving module, and a memory detecting module Connection, when the memory space of the Android system does not reach the set expected value, the lowest priority process is selected in all currently running processes; the process management service module is connected with the low memory driver module, and the priority is the lowest. The process matches all currently running other processes, finds all associated processes that are related to the lowest priority process, and obtains a stubborn process cluster; the process kills the module, connects with the process management service module, and kills the stubborn process. All associated processes included in the cluster release the memory space occupied by the processes.

The low memory driver module includes: a first traversal unit connected to the memory detection module, and traversing and obtaining a list of processes of all currently running processes when the memory space of the Android system does not reach the set expected value; priority a sorting unit, configured to store a preset rule for sorting processes according to priority from high to low; a process screening unit respectively connected to the first traversal unit and the priority sorting unit, and provided by the priority sorting unit The prioritization rule, from the list of processes obtained by the first traversal unit, filters the process with the lowest priority.

The process management service module includes: a package name storage unit, connected to the process screening unit to obtain package name information of a process with the lowest priority; and a second traversal unit connected to the package name storage unit to traverse all processes currently running The process list, and obtain the package name information of each process in the process list; the comparison unit is respectively connected with the package name storage unit and the second traversal unit, and the package name information of each process in the process list is separately selected from the filtered The packet name information of the process with the lowest priority is compared, and the associated process in which all the package name information matches the process with the lowest priority is detected; the sensing judgment module is respectively connected with the comparison unit and the package name storage unit, and is currently not used by the user. The package name information of the perceived association process is stored in the package name storage unit to obtain a stubborn process cluster.

The process killing module is connected to the package name storage unit in the process management service module, and all the processes corresponding to all the package name information stored therein are checked and killed.

The invention also provides a low memory killing method based on the Android system, based on the foregoing low memory killing system implementation, comprising the following steps:

S1, the memory detection module detects in real time whether the memory space of the Android system reaches the set expected value; when the expected value is not reached, the execution of S2 is continued;

S2. The low memory driver module filters out the lowest priority process among all currently running processes;

S3. The process management service module matches the lowest priority process with all currently running other processes, and finds all associated processes that are related to the lowest priority process, and obtains a stubborn process cluster;

S4. The process killing module kills all associated processes included in the stubborn process cluster, releases the memory space occupied by the processes, and returns to execute S1.

The S1 includes the following steps:

S11. Pre-store the expected value of the memory space required for the preset Android system to operate normally in the memory detection module;

S12. The memory detection module compares the detected actual value of the current memory space of the Android system with the preset expected value; when the actual value of the memory space is greater than or equal to the expected value, returns to execute S12; when the actual value of the memory space is small Continue to execute S2 at the expected value.

The S2 includes the following steps:

S21. The priority sorting unit stores a preset rule for sorting processes according to priority from high to low;

S22. The first traversal unit traverses and acquires a list of processes of all processes currently running.

S23. The process screening unit selects, according to the priority ordering rule stored in the priority sorting unit, the process with the lowest priority from the process list obtained by the first traversal unit.

In the S21, the rules for sorting the processes according to the priority from high to low are as follows:

First, according to the Android system, the process is divided into large classes, and sorted according to the priority from high to low: foreground process, visible process, secondary process, background process, content provider and empty process;

Then, according to the number of startups of each process and the time consumed by each startup, each major class of processes is further divided into small classes, and sorted according to the priority from high to low: the process with the most recent maximum probability being restarted, and the recent Processes with a higher probability of being restarted, and processes that have not been restarted in the near future;

Finally, according to the average startup time of each process, each process included in each small class process is sorted according to the priority from high to low. The process with the shortest average startup time has the lowest priority and the average startup time is the most. A long process with the highest priority.

The S3 includes the following steps:

S31. The package name storage unit obtains the package name information of the process with the lowest priority.

S32. The second traversal unit traverses the process list of all processes currently running, and obtains package name information of each process in the process list.

S33. The comparison unit compares the package name information of each process in the process list with the package name information of the selected lowest priority process, and determines whether the package name information of the two matches, and if yes, confirms that the process is The associated process that matches the lowest priority process until all processes in the process list are checked;

S34: The perceptual judgment module determines whether each associated process is perceived by the user; if yes, the associated process is added to the whitelist and discarded to clean up; if not, the package name information of the associated process is stored in the package name storage. In the unit, get a stubborn process cluster.

In the S34, the rule for determining whether the association process is perceived by the user is specifically:

S341, determining whether the associated process and the foreground process of the current operating state belong to the same task; if yes, determining that the associated process is perceived by the user; if not, proceeding to S342;

S342, determining whether the associated process is a process of the visible interface of the non-operational state; if yes, determining that the associated process is perceived by the user; if not, proceeding to S343;

S343. Determine whether the associated process is a process of an invisible interface that is currently in an operating state. If yes, determine that the associated process is perceived by the user. If not, determine that the associated process is not perceived by the user.

In summary, the low memory memory killing system and method based on the Android system of the present invention has the following advantages compared with the prior art: it is related to the process of checking and killing by thoroughly checking the association process. All the stubborn process clusters, avoid repeated repeated invalid killing work, and quickly and effectively recover the system memory space, so that the system Karton problem is relieved in time, effectively improve the user experience, and reduce system power consumption.

BRIEF DESCRIPTION OF THE DRAWINGS

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the embodiments or the prior art description will be briefly described below. It is obvious that the drawings in the following description are Some of the embodiments of the invention may be obtained by those of ordinary skill in the art in view of the drawings without departing from the scope of the invention.

1 is a flow chart of a low memory killing mechanism based on an Android system in the prior art;

2 is a schematic diagram of a working architecture of a low memory killing system based on an Android system in the present invention;

3 is a schematic structural diagram of a low memory killing system based on an Android system in the present invention;

4 is a schematic structural view of a low memory drive module in the present invention;

5 is a schematic structural diagram of a process management service module in the present invention;

6 is a basic flowchart of a low memory killing method based on an Android system in the present invention;

FIG. 7 is a detailed flowchart of a low memory killing method based on Android system in the present invention.

The best way to implement the invention

The technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the drawings in the embodiments of the present invention. Is this Some embodiments, rather than all of the embodiments, are invented. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present invention without creative efforts are within the scope of the present invention.

It should be noted that, herein, relational terms such as "first," "second," "third," and the like, if any, are used merely to distinguish one entity or operation from another. There is no requirement or implied that there is any such actual relationship or order between these entities or operations. It is to be understood that the terms so used are interchangeable, as appropriate, such that the embodiments of the invention described herein can be implemented, for example, in a sequence other than those illustrated or described herein. In addition, the terms "including", "comprising", "having", or any other variants are intended to encompass a non-exclusive inclusion, such that a process, method, article, or terminal device that includes a plurality of elements includes not only those elements but also Includes other elements not explicitly listed, or elements that are inherent to such a process, method, item, or terminal device. An element defined by the phrase "including" or "comprising" does not exclude the presence of additional elements in the process, method, article or terminal device including the element. In addition, in this document, “greater than”, “less than”, “exceeded”, etc. are understood as not including the number; “above”, “below”, “inside”, etc. are understood to include the number.

The technical solutions of the present invention will be described in detail below with reference to FIGS. 2 to 7 in a specific embodiment. The following specific embodiments may be combined with each other, and the same or similar concepts or processes may not be described in some embodiments.

FIG. 2 is a schematic diagram of a working architecture of a low-memory killing system based on an Android system provided by the present invention; wherein the Android system is generally applied to a mobile phone, or a tablet computer, or a smart wearable device (including smart A mobile intelligent terminal such as a watch or a smart bracelet includes: a kernel driver layer (Kernel), which is a hardware driver running layer of a mobile intelligent terminal, and is an abstraction layer between hardware and software processes; a framework layer is The link layer between the application layer and the kernel driver layer; the application layer (App), where each application process in the mobile smart terminal runs.

As shown in FIG. 3 , the schematic diagram of a low-memory killing system based on the Android system provided by the present invention includes: a memory detecting module 1 , which detects in real time whether the memory space of the Android system reaches a set expected value; a low memory driver Module 2, which is disposed in the kernel driver layer of the Android system, is connected to the memory detecting module 1 and is filtered out in all currently running processes when the memory space of the Android system does not reach the set expected value. The process with the lowest priority; the Process Management Service (AMS) module 3 is set in the framework layer of the Android system and is connected to the low memory driver module 2, and the process with the lowest priority and all other processes currently running. Perform matching, find all associated processes that are related to the lowest priority process, and obtain stubborn process clusters; process killing module 4, connect with process management service module 3, and kill all associated processes included in the stubborn process cluster , free up the memory space occupied by these processes.

In the memory detecting module 1, the expected value (threshold value) of the memory space required for the normal operation of the Android system is stored. After detecting the actual value of the current memory space of the Android system, the memory detecting module 1 compares with the preset expected value; if the actual value of the memory space is greater than the expected value, the current memory space of the Android system reaches the set expectation. The value, that is, the memory space is sufficient; if the actual value of the memory space is less than the expected value, the current memory space of the Android system does not reach the set expected value, that is, the memory space is insufficient, and the memory detection module 1 will trigger the low memory driver. Module 2 starts, and needs to kill the lowest priority process or all associated processes related to the process, thereby freeing up the memory space occupied by the processes, so that the Android system can obtain the memory space required for normal operation.

As shown in FIG. 4 , it is a schematic structural diagram of the low memory drive module 2, including: a first traversal unit 21 connected to the memory detection module 1 and traversing when the memory space of the Android system does not reach the set expected value. And obtaining a process list of all processes currently running; a priority sorting unit 22, configured to store a preset rule for sorting the processes according to priority from high to low; the process screening unit 23, respectively, and the first The traversing unit 21 and the priority sorting unit 22 are connected, and the process with the lowest priority is selected from the process list acquired by the first traversing unit 21 according to the priority ordering rule provided in the prioritizing unit 22.

The rules for sorting the processes according to the priorities from high to low are stored in the priority sorting unit 22, and specifically include: first, classifying the processes according to the Android system, and sorting the processes according to the priority from high to low. It is: foreground process, visible process, secondary process, background process, content provider and empty process; then, according to the number of startups of each process and the time consumed by each startup, each class process is further divided into subclasses. And sorted according to the priority from high to low: the process with the most recent maximum probability being restarted, the process with a recent high probability of being restarted, and the process that has not been restarted recently; finally, according to the average startup time of each process , the processes included in each small class process are sorted according to the priority from high to low, wherein the process with the shortest average startup time is given priority. The process with the lowest level and the longest average startup time has the highest priority.

Among them, first introduce the six major processes of the Android system in detail, namely:

1. Foreground App: refers to the process and some system processes currently displayed on the screen of the intelligent mobile terminal; in principle, such processes are almost impossible to be killed by the low memory killing system;

Representative process: The app that the user is currently using to read the news, or the app that the user is currently using to browse the web.

2, visible process (Visible App): Although this part of the process is not displayed in the foreground of the intelligent mobile terminal, but it is closely related to the user's use, in principle, it belongs to the process that the user does not want to be stopped, so usually In the case, it will not be terminated by the low memory killing system;

Representative process: input method.

3, Secondary Process (Secondary App): Although this part of the process belongs to the secondary process, but it is still closely related to some commonly used system functions, users still need to use them from time to time, so they are not expected to be low memory killing system Termination of killing;

Representative process: contact storage function.

4, Background Process (Background App): is the process that is normally understood to be switched to the background after startup. That is to say, when the process is displayed on the screen of the smart mobile terminal, the process that it runs is the foreground process, and once the user presses the Home button (non-Back return key) to return to the main interface, the process is resident. In the background, become a background process. Usually such background processes are the target objects of the low memory killing system;

Representative process: A game app that the user is running before. Because the user has other usage requirements for the smart mobile terminal, after pressing the Home button, the game app is switched to the background process.

5, Content Provider (Content Provider): refers to no process entity, only provide content for other processes to use. In general, such a process is also the target of a low-memory killing system, which is very likely to be investigated and terminated.

Representative process: calendar provisioning node.

6: Empty App (Empty App): After the process exits, there will still be an empty process in the process. There is no data running in this process. The effect is often to increase the next startup speed of the process or record some processes. Calendar History information. There is no doubt that this type of process is the primary troubleshooting target of the low-memory killing system, and should be terminated first to release memory.

According to the above, although the present invention prioritizes the priority of these six types of processes, in the actual application process, the foreground process, the visible process, and the secondary process are basically non-existent (but not Absolutely) the possibility of being killed, and all the killing objects are concentrated in the three processes of background processes, content providers and empty processes.

After the process first sorts the priorities according to the categories, further processing of each process included in each category is further performed. The specific ordering rules are:

First, according to the pre-stated number of recent startups of each process and the time consumed by each startup, calculate the average startup duration of each process separately, and determine the recent maximum probability based on the average startup duration of each process. The process that is restarted, the process that will be restarted in the near future, and the process that will not be restarted in the near future.

Specifically, the average startup time of the process is calculated according to the following formula:

Where t _avg represents the average startup time of the process; n represents the total number of times the process has recently started; t _n represents the startup time of the process from the current time in the n starts.

Make the following judgments:

When t _avg -(t _c -t _n )>0 and |(t _avg -(t _c -t _n ))| _≤ t _avg -t _c , it is determined that the process belongs to a process in which the recent maximum probability is restarted;

When t _avg -(t _c -t _n )≤0 and |(t _avg -(t _c -t _n ))| ≤ t _avg -t _c , it is determined that the process belongs to a process in which a recent large probability is restarted; At this point, the time point at which the pre-estimated process started is missed, but the process has not yet been started, and the process is likely to start immediately later; therefore, the process is determined to be a process with a relatively high probability of being restarted in the near future. ;

When t _avg -(t _c -t _n )>0 and |(t _avg -(t _c -t _n ))|>t _avg -t _c , it is determined that the process belongs to a process that will not be restarted in the near future;

Where t _c represents the current time.

Then, each small class of processes included in each major process is sorted according to the priority from high to low: the process with the most recent maximum probability being restarted, the process with a recent high probability of being restarted, and will not be restarted in the near future. Process.

Finally, for each process included in each small class process, the priority is sorted from high to low according to the average startup time t _{avg of} each process, wherein the process with the shortest startup time t _{avg has the} lowest priority. The process with the longest start-up time t _{avg has the} highest priority.

In a preferred embodiment of the present invention, after the low memory driver module 2 is triggered to be started, the first traversal unit 21 traverses all the running process lists obtained, and there is only one empty process; the priority ordering unit 22 The priority ranking rule stored in the process belongs to the process with the lowest priority, and is directly filtered by the process screening unit 23.

In the second preferred embodiment of the present invention, after the low memory driver module 2 is triggered to be started, the first traversal unit 21 traverses the obtained list of all running processes, there is no empty process, but there is only one content. Provider; according to the priority ranking rule stored in the prioritization unit 22, since there is no empty process running, the content provider becomes the process with the lowest priority and is filtered by the process screening unit 23.

In the third preferred embodiment of the present invention, after the low memory driver module 2 is triggered to be started, the first traversal unit 21 traverses the obtained list of all running processes, there is no empty process, and there is no content provider. However, there are 3 background processes, and the 3 background processes belong to the process whose recent maximum probability is restarted, the process whose recent probability is restarted, and the process which will not be restarted in the near future; The stored prioritization rule, in which the process that will not be restarted in the near future belongs to the process with the lowest priority, is thus filtered by the process screening unit 23.

In the fourth preferred embodiment of the present invention, after the low memory driver module 2 is triggered to be started, the first traversal unit 21 traverses the list of all running processes acquired, there is no empty process, and there is no content provider. However, there are 3 background processes, and these 3 background processes belong to the process that will not be restarted in the near future. In this case, the priority is further sorted according to the average startup time of each process, and the process with the shortest average startup time is The lowest priority will be filtered by the process screening unit 23. When the average startup time of a process is the shortest, it indicates the initiation of the process. The fastest speed, temporarily stop running, the time spent on the next restart is the shortest; therefore, the process that keeps the slow start speed continues to run in the background, selects the fastest startup process to check and kill, temporarily releases the memory. Space, even if the subsequent user starts the process again, it will not cause the startup time to be too long, so that the user experience can be improved.

As shown in FIG. 5, it is a schematic structural diagram of the process management service module 3, including: a package name storage unit 31, connected to the process screening unit 23, and acquiring package name information of a process with the lowest priority; the second traversal unit 32 Connected to the package name storage unit 31, after the package name storage unit 31 acquires the package name information of the process with the lowest priority, traverses the process list of all processes currently running, and acquires the package name information of each process in the process list. The comparison unit 33 is connected to the package name storage unit 31 and the second traversal unit 32, respectively, and compares the package name information of each process in the process list with the package name information of the selected lowest priority process, and performs troubleshooting. An association process in which all the package name information matches the process with the lowest priority; the perception determination module 34 is connected to the comparison unit 33 and the package name storage unit 31, respectively, and stores the package name information of the associated process that is not currently perceived by the user to In the package name storage unit 31, a stubborn process cluster is obtained.

The rule that the sensing determining module 34 determines whether the associated process is perceived by the user is: determining whether the associated process and the foreground process currently in the operating state belong to the same task, and if so, determining that the associated process is perceived by the user; otherwise, further determining Whether the associated process is a process of a visible interface in a non-operational state, and if so, the associated process is considered to be perceived by the user; otherwise, the process of determining whether the associated process is an invisible interface of the currently operating state is continued, and if so, the associated process is considered The user perceives, otherwise the associated process is considered not to be perceived by the user.

The process of the visible interface of the non-operational state may specifically be a process related to the use of the user, such as an input method. The process of the invisible interface of the operating state may specifically be a process of playing music, or a process of performing a download task, etc., which does not need to be visible in the interface of the smart mobile terminal, but is currently being operated by the user. process.

The process killing module 4 is connected to the package name storage unit 31 in the process management service module 3, and all the processes corresponding to all the package name information stored therein are checked and killed, so as to completely eliminate the stubborn process cluster and prevent the stubborn process. Start again.

As shown in FIG. 6, the present invention further provides a low memory killing method based on an Android system, which is based on the aforementioned low Memory killing system implementation, suitable for mobile smart devices such as mobile phones, or tablets, or smart wearable devices (including smart watches or smart bracelets), including the following steps:

S1, the memory detection module 1 detects in real time whether the memory space of the Android system reaches the set expected value; when the expected value is not reached, triggering to start the low memory drive module 2, and continue to execute S2;

S2, the low memory driver module 2 screens out the lowest priority process among all currently running processes;

S3. The process management service module 3 matches the lowest priority process with all currently running other processes, and finds all associated processes that are related to the lowest priority process to obtain a stubborn process cluster.

S4. The process killing module 4 kills all associated processes included in the stubborn process cluster, releases the memory space occupied by the processes, and returns to execute S1.

The S1 includes the following steps:

S11. Pre-store the expected value of the memory space required for the normal operation of the Android system in the memory detecting module 1;

S12. The memory detecting module 1 compares the detected actual value of the current memory space of the Android system with the preset expected value.

When the actual value of the memory space is greater than or equal to the expected value, it indicates that the current memory space of the Android system reaches the set expected value, that is, the memory space is sufficient, and the execution returns to S12;

When the actual value of the memory space is less than the expected value, the current memory space of the Android system does not reach the set expected value, that is, the memory space is insufficient, and S2 is continued.

As shown in FIG. 7, the S2 includes the following steps:

S21. The priority sorting unit 22 stores a preset rule for sorting the processes according to the priority from high to low;

S22. The first traversal unit 21 traverses and acquires a process list of all processes currently running.

S23. The process screening unit 23 selects the process with the lowest priority from the process list acquired by the first traversal unit 21 according to the priority ordering rule stored in the priority sorting unit 22.

First, according to the Android system, the process is divided into large classes and sorted according to the priority from high to low: foreground process, visible process, secondary process, background process, content provider and empty process;

It should be noted that although the present invention prioritizes the priority of these six types of processes, in the actual application process, the foreground process, the visible process, and the secondary process are basically non-existent (but It is not absolute) the possibility of being killed, and all the killing objects are concentrated in the three processes of background processes, content providers and empty processes.

Among them, the specific method for subclassing each major class of processes is:

When t _avg -(t _c -t _n )≤0 and |(t _avg -(t _c -t _n ))| ≤ t _avg -t _c , it is determined that the process belongs to a process in which a recent large probability is restarted;

Where t _avg represents the average startup time of the process; t _c represents the current time; t _n represents the last startup time of the process from the current time in n starts; n represents the total number of times the process has recently started;

Moreover, the average startup time t _avg of the process is calculated as:

As shown in FIG. 7, the S3 includes the following steps:

S31. The package name storage unit 31 acquires package name information of the process with the lowest priority.

S32. The second traversal unit 32 traverses the process list of all processes currently running, and obtains package name information of each process in the process list.

S33. The comparing unit 33 compares the package name information of each process in the process list with the package name information of the selected lowest priority process, and determines whether the package name information of the two matches, and if yes, confirms the process. Is the associated process that matches the lowest priority process until all processes in the process list are checked.

S34. The perceptual judgment module 34 determines whether each associated process is perceived by the user; if yes, the associated process is added to the whitelist and discarded to clean up; if not, the package name information of the associated process is stored to the package name. In the storage unit 31, a stubborn process cluster is obtained.

In a preferred embodiment of the present invention, when the memory detecting module 1 detects that the memory space of the Android system does not reach the set expected value, triggering and starting the low memory driving module 2; the low memory driving module 2 filters out all current The only one empty process in the running process list is the process with the lowest priority. After the process management service module 3 is checked, no related process has been found. Therefore, the process killing module 4 will be empty. Process killing cleanup.

However, after the empty process is cleaned up, the memory detection module 1 detects that the memory space of the Android system has not reached the set expected value, and continues to be filtered by the low memory driver module 2, and no empty process is found, and no content is found. The donor, but finds 4 background processes, in which 4 low-priority processes that will not be restarted in the near future are filtered out, and then the average startup time is selected in the 2 processes. The process, which is the lowest priority process, is reported to the process management service module 3. After the process management service module 3 is checked, a number of associated processes with which correlations are found are found, and all associated processes are not perceived by the user, so the process killing module 4 includes the stubborn process cluster (including the lowest priority process and its All associated processes) are all cleaned up.

Since the memory space of the Android system still does not reach the set expected value, the low memory driver module 2 filters out another background process whose average startup time is long and will not be restarted in the near future is the lowest priority process, and is managed by the process. After the service module 3 is checked, an associated process with which it has relevance is found. However, the association process is determined to be perceived by the user after being judged, so the associated process is abandoned and killed, and the final process killing module 4 only kills the process with the lowest priority. Subsequently, it was found that the memory space of the Android system has reached the set expected value, and the process of killing and killing the process will not be performed temporarily.

In summary, the low-memory killing system and method based on the Android system provided by the present invention triggers a low-memory driver module by setting a connection communication channel of the process management service module 3 between the low-memory driver module 2 and each process. At 2 o'clock, it reports the process with the lowest priority to the process management service module 3, and the process management service module 3 matches all the processes with the lowest priority by matching the package name information. The sexual association process acquires the stubborn process cluster, so that the process killing module 4 can clean up and clean it up at one time, prevent the stubborn process cluster from starting again, and effectively improve the effect of memory recycling. In order to not affect the normal use and experience of the user, the associated process needs to be judged by the user, and when it is found that it is being perceived by the user, it is forgotten to be cleaned up.

Compared with the prior art, the low memory killing system and method based on the Android system of the present invention has the following advantages: by checking the association process, completely removing all stubborn process clusters that are related to the process that needs to be killed and killed. Avoid repeated repeated invalidation and killing work, and quickly and effectively recover the system memory space, so that the system can be relieved in time, effectively improve the user experience, and reduce system power consumption.

Those skilled in the art will appreciate that the various embodiments described above can be provided as a method, apparatus, or computer program product. These embodiments may take the form of an entirely hardware embodiment, an entirely software embodiment, or a combination of software and hardware aspects. All or part of the steps involved in the above embodiments may be programmed to execute related hardware. The program may be stored in a storage medium readable by the computer device for performing all or part of the steps described in the methods of the above embodiments.

The above embodiments are described with reference to flowcharts and/or block diagrams of methods, apparatus (systems), and computer program products according to the embodiments. It will be understood that each flow and/or block of the flowchart illustrations and/or FIG. These computer program instructions can be provided to a processor of a computer device to produce a machine such that instructions executed by a processor of the computer device are generated for implementing one or more blocks or processes in a flow or flow diagram and/or block diagram of the flowchart The device for the function specified in the box.

Although the present invention has been described in detail by the preferred embodiments thereof, it should be understood that the foregoing description should not be construed as limiting. Various modifications and alterations of the present invention will be apparent to those skilled in the art. Therefore, the scope of the invention should be defined by the appended claims.

Claims

A low memory killing system based on Android system, characterized in that it comprises:

The memory detection module detects in real time whether the memory space of the Android system reaches the set expected value;

The low memory driver module is connected to the memory detection module. When the memory space of the Android system does not reach the set expected value, the lowest priority process is selected in all currently running processes;

The process management service module is connected to the low memory driver module, and matches the lowest priority process with all currently running other processes, and finds all associated processes that are related to the lowest priority process, and obtains a stubborn process cluster. ;

The process killing module is connected with the process management service module to kill all associated processes included in the stubborn process cluster and release the memory space occupied by the processes.
The low memory memory killing system of the Android system according to claim 1, wherein the low memory driver module comprises:

The first traversal unit is connected to the memory detecting module, and when the memory space of the Android system does not reach the set expected value, traverses and acquires a list of processes of all processes currently running;

a prioritization unit for storing a preset rule for sorting processes according to priority from high to low;

The process screening unit is respectively connected to the first traversal unit and the priority sorting unit, and according to the priority sorting rule provided in the prioritizing unit, the screen with the lowest priority is selected from the process list obtained by the first traversal unit. process.
The low memory memory killing system of the Android system according to claim 2, wherein the process management service module comprises:

a package name storage unit, connected to the process screening unit, to obtain the package name information of the process with the lowest priority;

a second traversal unit, connected to the package name storage unit, traversing the process list of all processes currently running, and obtaining package name information of each process in the process list;

Comparing units, respectively connected to the package name storage unit and the second traversal unit, each of the process list The package name information of the process is compared with the package name information of the selected lowest priority process, and the associated process in which all the package name information matches the process with the lowest priority is found out;

The sensing determination module is respectively connected to the comparison unit and the package name storage unit, and stores the package name information of the associated process that is not currently perceived by the user into the package name storage unit to obtain a stubborn process cluster.
The Android system-based low memory killing system according to claim 3, wherein the process killing module is connected to the package name storage unit in the process management service module, and all the package name information stored therein is correspondingly The process is all killed.
A low memory killing method based on the Android system, characterized in that the low memory killing system according to any one of claims 1 to 4 is implemented, comprising the following steps:

S1, the memory detection module detects in real time whether the memory space of the Android system reaches the set expected value; when the expected value is not reached, the execution of S2 is continued;

S2. The low memory driver module filters out the lowest priority process among all currently running processes;

S3. The process management service module matches the lowest priority process with all currently running other processes, and finds all associated processes that are related to the lowest priority process, and obtains a stubborn process cluster;

S4. The process killing module kills all associated processes included in the stubborn process cluster, releases the memory space occupied by the processes, and returns to execute S1.
The method of claim 5, wherein the S1 includes the following steps:

S11. Pre-store the expected value of the memory space required for the preset Android system to operate normally in the memory detection module;

S12. The memory detection module compares the detected actual memory space of the current Android system with the preset expected value; when the actual value of the memory space is greater than or equal to the expected value, the process returns to execute S12; when the actual value of the memory space is less than expected Value, continue to execute S2.
The method of claim 5, wherein the S2 includes the following steps:

S21. The priority sorting unit stores a preset rule for sorting processes according to priority from high to low;

S22. The first traversal unit traverses and acquires a list of processes of all processes currently running.

S23. The process screening unit selects, according to the priority ordering rule stored in the priority sorting unit, the process with the lowest priority from the process list obtained by the first traversal unit.
The low-memory-based killing method of the Android system according to claim 7, wherein in the S21, the rules for sorting the processes according to the priority from high to low are as follows:

First, according to the Android system, the process is divided into large classes, and sorted according to the priority from high to low: foreground process, visible process, secondary process, background process, content provider and empty process;

Then, according to the number of startups of each process and the time consumed by each startup, each major class of processes is further divided into small classes, and sorted according to the priority from high to low: the process with the most recent maximum probability being restarted, and the recent Processes with a higher probability of being restarted, and processes that have not been restarted in the near future;

Finally, according to the average startup time of each process, each process included in each small class process is sorted according to the priority from high to low. The process with the shortest average startup time has the lowest priority and the average startup time is the most. A long process with the highest priority.
The method of claim 7, wherein the S3 includes the following steps:

S31. The package name storage unit obtains the package name information of the process with the lowest priority.

S32. The second traversal unit traverses the process list of all processes currently running, and obtains package name information of each process in the process list.

S33. The comparison unit compares the package name information of each process in the process list with the package name information of the selected lowest priority process, and determines whether the package name information of the two matches, and if yes, confirms that the process is The associated process that matches the lowest priority process until all processes in the process list are checked;

S34: The perceptual judgment module determines whether each associated process is perceived by the user; if yes, the associated process is added to the whitelist and discarded to clean up; if not, the package name information of the associated process is stored in the package name storage. In the unit, get a stubborn process cluster.
The low-memory-based killing method of the Android system according to claim 9, wherein in the S34, the rule for determining whether the associated process is perceived by the user is specifically:

S341, determining whether the associated process and the foreground process of the current operating state belong to the same task; if yes, determining that the associated process is perceived by the user; if not, proceeding to S342;

S342, determining whether the associated process is a process of the visible interface of the non-operational state; if yes, determining that the associated process is perceived by the user; if not, proceeding to S343;

S343. Determine whether the associated process is a process of an invisible interface that is currently in an operating state. If yes, determine that the associated process is perceived by the user. If not, determine that the associated process is not perceived by the user.