Android process priority

Android process priority

Process Priority

12.1.1. Overview
Android rules: process priority is divided into the following five levels, as shown in-1:
Figure-1
1. Foreground process-Activte process
Active (foreground) process is the application that contains (interactive with users) controls. These are processes that Android tries to protect by recycling resources. Active process includes:
(1) activities in the "active" status run on the frontend to respond to user events.
(2) Activity Service or Broadcast Receiver er that is executing the onReceive event processing function.
(3) The onStart, onCreate, and OnDestroy event processing functions are being executed.
2. Visible Process-Visible Process
Visible but inactive processes are those with "visible" Activity. "Visible" Activity is the Activity that is visible on the screen but not on the foreground or does not respond to user events. This occurs when an Activity is partially covered (a non-full screen or transparent Activity ). It can be seen that the Process is killed only in extreme cases to ensure the running of the Active Process. This includes the following situations:
(1) visible Activity, but in the onPause () State;
(2) Services bound to the visible Activity
3. Service process
The process contains the started Service. The Service is continuously running in a dynamic manner, but there is no visible interface. Because services do not directly interact with users, they have a lower priority than visible Process. They can still be considered as front-end processes and won't be killed until resources are required by active/visible Process.
4. Background process
The Activity in the process is invisible and there is no started Service in the process. These processes can be considered as background processes. In the system, there are a large number of background processes, and Android kills background processes according to the principle of "first kill" to obtain resources for foreground processes.
5. Empty process-Empty process
To improve the performance of the entire system, Android often retains the applications that have completed the lifecycle in the memory. Android maintains these caches to improve the restart time of the application. These processes are often killed when resources are needed.
When a process is killed, the process is retained and becomes an empty process.
12.1.2. How to Set/cancel a Service as a foreground Process
As described above, the Service is the third priority of the process. Generally, time-consuming operations are placed in the thread, so such threads will have a higher priority in the Service, reduce the chances of being killed by the Android system.
If the thread is placed in the Activity, when the Activity is completely covered and in the onStop state, the priority of the process is reduced to level 4. It is obviously better to put it in a third-level Service to be more secure.
In application scenarios, such as music players, when other operations are performed on the front-end, the music player plays music in the background. In this case, it is appropriate to place the playing thread in the Service.
There are two methods in the Service class, which are used to set the Service as the foreground process and cancel the foreground process respectively. Services set as foreground processes have the highest priority, and the chances of being killed by the Android system are minimized.
1. startForeground (int id, Notification noti );
Purpose: set the Service object as a foreground process.
Note:
The first parameter is the notification id value.

The second parameter is the notification object.
The parameters of the startForegroud method are the same as those of the notification manager. Both send a notification and specify the id of the notification object.
2. stopForeGround (int id );
Purpose: cancel the foreground process (the Service object notified by the specified id value.
12.1.3. Procedure for setting Service as a foreground Process
Step 1. Create an Intent object in the onStartCommand method of the Service class (usually in this method) and specify the Activity to which it is bound. The sample code is as follows:
Intent foreIntent = new Intent (this, MainActivity. class );
Step 2. Create a PendingIntetn object
PendingIntent pintent = PendingIntent. getActivity (
This, 0, foreIntent, PendingIntent. FLAG_UPDATE_CURRENT );
Note: The fourth parameter indicates to refresh the notification at any time in the notification bar.
Step 3. Create a notification object. The sample code is as follows:
Notification noti = new Notification (
R. drawable. icon, "notification", System. currentTimeMillis ());
Note:
The first parameter is the icon of this Notification displayed in the notification bar.
The second parameter is the title of the notification displayed in the notification bar.
The third parameter is the time when the notification is sent.
Step 4. Place the notification in the Ongoing group. The sample code is as follows:
Noti. flags = Notification. FLAG_ONGOING_EVENT;
Step 5. Set the notification click event. The sample code is as follows:
Noti. setLatestEventInfo (this, "title", "content", pintent );
Step 6. send a notification to the specified Activity and set the current Service object as a foreground process. The sample code is as follows:
StartForeground (97789, noti );
12.1.4. Example
Run the window shown in-1:
Figure 2
1. Click the start foreground button in figure-1 to start a Service object and change the Service to a foreground process, the first line of information in the red box in figure-2 appears in the log window.
2. Click the stop foreground button in Figure 2 to cancel the current Service process and display the second line in the red box in Figure 2 in the log window.
The following lists the key code:
The package name is com.tarena.exe r12_01, and the project entry is MainActivity. The key code in this example is as follows:
@ Override
Public void onClick (View v ){
// Create an Intent object and set the target component to MyService
Intent intent = new Intent ();
Intent. setClass (this, MyService. class );
Switch (v. getId ()){
Case R. id. btnStartFore:
// Set intent. action to Constant. ACTION_FORE.
Intent. setAction (Constant. ACTION_FORE );
StartService (intent); // start the service
Break;
Case R. id. btnStopFore:
// Set intent. action to Constant. ACTION_STOP_FORE
Intent. setAction (Constant. ACTION_STOP_FORE );
StartService (intent );
Break;
Case R. id. btnStopService:
StopService (intent); // stop the service
Break;
}
}
Step 2. Create the MyService. java class under the src/com.tarena.exe r12_01 package to inherit from the Service class. The key code is as follows:
@ Override
Public int onStartCommand (Intent intent, int flags, int startId ){
String action = intent. getAction ();
If (Constant. ACTION_FORE.equals (action )){
Log. I (tag, "startForeground ");
Intent foreIntent = new Intent ();
ForeIntent. setClass (this, MainActivity. class );
PendingIntent pintent = PendingIntent. getActivity (
This, 0, foreIntent, PendingIntent. FLAG_UPDATE_CURRENT );
Notification noti = new Notification (
R. drawable. icon, "notification", System. currentTimeMillis ());
// Place the notification to the "Ongoing" group in the notification bar, that is, the "running" group.

Noti. flags = Notification. FLAG_ONGOING_EVENT;
Noti. setLatestEventInfo (
This, "Change Service priority", "set service to foreground level", pintent );
StartForeground (97789, noti );
} Else if (Constant. ACTION_STOP_FORE.equals (action )){
Log. I (tag, "stopForeground ");
StopForeground (true); // cancel the current service as the foreground Service
}
Return super. onStartCommand (intent, flags, startId );
}
Step 3. Open the project list file and register the Service, as shown in the code in the red box below:
<Application android: icon = "@ drawable/icon"
Android: label = "@ string/app_name">
<Service android: name = "MyService"> </service>
</Application>
12.2.UI and thread
12.2.1. Overview
UI is short for English User Interface words.
When an application starts, the system creates a main thread or UI thread for the application, which is responsible for distributing events to different controls (such as painting events) to complete the interaction between the application and the Android UI.
For example, when you touch a button on the screen, the UI thread will distribute the touch event to the control, change the status and add it to the event queue. The UI thread will distribute requests and notifications to each control, complete the action.
The performance of the single-threaded model is very poor unless the application is quite simple, especially when all operations are executed in the main thread, for example, time-consuming operations such as accessing the network or database will cause the user interface to be locked, and all events will not be distributed, and the application will be like dead, more seriously, the system will pop up the "Application No response" dialog box when it exceeds 5 seconds.
12.2.2.main thread
The main thread is also called the UI thread. The main thread is responsible for UI creation, UI refreshing, and handling user input events.
Tip: Android requires that the main thread is responsible for refreshing the controls in the Activity. Other threads cannot be refreshed directly.
12.2.3.ANR terminology
The full name of ANR: Activity or Application is not responding. When the user's operation exceeds the system's response time, the ANR dialog box is displayed, as shown in-3:
Figure-3
If Force close is selected, the current Activity is forcibly disabled;
If you select the Wait button, the current Activity is retained.
Conditions for ANR:
1. There is a time-consuming operation being executed in the main thread (or main thread). At this time, the ANR will pop up when the user inputs an event and the event does not receive a response within 5 seconds.
2. If the onReceive () method of the broadcast receiver is not completed within 10 seconds, an ANR will pop up.
Tip: do not perform time-consuming operations in the onReceive method of the broadcast receiver.
12.2.4. Example-test ANR in two cases
Create Project exer12_02 and create the mycycler class in this class. This class is a subclass of BroadcastRecevier.
Figure 4
1. Click the download button to perform a loop simulation of downloading data from the network in the main thread. This loop takes 10 seconds, try to enter a string continuously in the edit box specified by the annotation in figure-4. After 5 seconds, the ANR dialog box shown in figure-3 is displayed.
2. Click the send broadcast button to send a broadcast. Then, in the edit box in figure-4, the ANR dialog box is displayed.
The following is the key code:
Step 1. Create the tool class-CommonUtils. java, which defines a loop to simulate time-consuming operations. The Code is as follows:

Public final class CommonUtils {
Public static final String ACTION_RECEIVER = "com.tar ena. ACTION_RECEIVER ";
Public static void timeConsuming (int n ){
For (int I = 0; I <n; I ++ ){
Try {
Thread. sleep (1000 );
} Catch (InterruptedException e ){
E. printStackTrace ();
}
}
}
}
Step 2. Create the MyReceiver. java class that inherits from the BroadcastReceiver class. The Code is as follows:
Public class MyReceiver extends BroadcastReceiver {
Private static final String tag = "MyReceiver ";
@ Override
Public void onReceive (Context context, Intent intent ){
Log. I (tag, "oncycler ");
CommonUtils. timeConsuming (15 );
}
}
Step 3. The following is the MainActivity. java code, which is used to send broadcasts and simulate time-consuming download operations. The Code is as follows:
Public class MainActivity extends Activity implements OnClickListener {
TextView mTextView;
@ Override
Public void onCreate (Bundle savedInstanceState ){
Super. onCreate (savedInstanceState );
SetContentView (R. layout. main );
MTextView = (TextView) findViewById (R. id. TV );
// Instantiate the Button Object
Button btnDownload = (Button) findViewById (R. id. btnDownload );
Button btnSendBraodcast = (Button) findViewById (R. id. btnSendBroadcast );
// Register the Click Event of the button object
BtnDownload. setOnClickListener (this );
BtnSendBraodcast. setOnClickListener (this );
}
// Click the event of the implementation button
@ Override
Public void onClick (View v ){
Switch (v. getId ()){
Case R. id. btnDownload: // Download button
CommonUtils. timeConsuming (10); // simulate (10 seconds) download
MTextView. setText ("finished ");
Break;
Case R. id. btnSendBroadcast: // send broadcast button
// Send Broadcast
Intent intent = new Intent (CommonUtils. ACTION_RECEIVER );
SendBroadcast (intent );
MTextView. setText ("finished ");
Break;
}
}
}
12.3.Message object
12.3.1. Overview
The Message class is used to store messages. This class is usually used with the Handler class.
12.3.2. common attributes
1. int arg1: stores an int type of data.
2. int arg2: stores an int type of data.
3. int what: store an int type of data.
4. Object obj: stores any type of objects.
12.3.3. Sample Code
Message msg = new Message ();
Msg. what = 1;
Msg. arg1 = 100;
Msg. obj = "hello ";
Msg. obj = new Runnable ();
12. 4. Update the UI with Handler
12.4.1. Overview
As described above, time-consuming operations should not be performed in the main thread. Therefore, time-consuming operations are usually stored in other threads. Androidghi calls such threads work threads ). However, Android also stipulates that only the main thread can modify the controls in the Activity. Other threads cannot modify the controls.
There are multiple ways to solve the above problem. This section describes how to solve the problem that the working thread cannot directly modify the UI through the methods provided by the Handler class.
Handler's idea of modifying the UI of the main thread: the Handler object sends a message in the work thread, and the message is sent to the Message pair column for processing.
Receives messages from the message pair column in the main thread, and determines how to update the UI in the main thread based on the information in the message.
12.4.2. Common Methods
1. sendEmptyMessage (int what );
Purpose: Send an empty message from the work thead (working thread) to the main thread.

NOTE: If multiple threads send messages to the main thread, what is the parameter used to differentiate different threads.
2. sendEmptyMessageAtTime (int what, long uptime );
Purpose: Send an empty message from the work thead (working thread) at a specified time.
Note: The second parameter, uptime, is the specified time.
3. sendEmptyMessageDelayed (int what, long delay );
Purpose: Send an empty message delayed from the work thead (working thread.
Description: The second parameter is used to specify the delay time, in milliseconds.
5. sendMessage (Message msg );
Purpose: Send messages from the work thead (working thread) to the main thread;
Note: msg is the object for storing message data.
6. sendMessageAtTime (Message msg, long uptime );
Purpose: send messages to the main thread at the specified time from work thead (working thread ).
7. sendMessageDelayed (Message msg, long delay );
Purpose: send messages to the main thread at a specified time from the work thead (working thread) delay.
8. handleMessage (Message msg );
Purpose: Receive and process messages sent from the work thread.
Description: The Message object sent by the parameter-msg: send *** Message.
Figure-5 is the message processing mechanism of Android:
Figure 5
Figure-5 shows that the Android system provides a Looper (loop-to-column) function to manage message-to-column pairs, each thread sends messages to the Message pair column through the Send *** Message command of the Handler class, and logoff then delivers the messages in the Message pair column to the main thread for processing in sequence.
12.4.3. Example
Different messages are sent from two working threads to the main thread. The main thread receives messages and displays different processing information.
Step 1. The code in The onClick () method in the Activity class is as follows. This method is used to process button-click events.
@ Override
Public void onClick (View v ){
Switch (v. getId ()){
Case R. id. btnDownload: // if you click Download
// Create a work thread object
New Thread (){
Public void run (){
// The following line of code simulates the download progress. The execution time is about 10 seconds.
CommonUtils. timeConsuming (10 );
// Create a message object
Message msg = new Message ();
// CommonUtils. FLAG_DOWNLOAD value indicates the download operation
Msg. what = CommonUtils. FLAG_DOWNLOAD;
Msg. obj = "download finished ";
MHandler. sendMessage (msg); // send a message
};
}. Start (); // start the thread
Break;
Case R. id. btnUpdate: // if you click the button with the title updated
// Create a work thread (working thread object)
New Thread (){
Public void run (){
// The following line of code simulates the update progress. The execution time is about 10 seconds.
CommonUtils. timeConsuming (8 );
// Create a message object
Message msg = new Message ();
// CommonUtils. FLAG_UPDATE indicates the update operation.
Msg. what = CommonUtils. FLAG_UPDATE;
Msg. obj = "update finished ";
MHandler. sendMessage (msg); // send a message
};
}. Start (); // start the thread
Break;
}
}
Step 2. The following is the Handler object-mHandler created in the Activity. onCreate () method (main thread:
Button btnDownload. setOnClickListener (this );
Button btnUpdate. setOnClickListener (this );
MHandler = new Handler (){
@ Override
Public void handleMessage (Message msg ){
Switch (msg. what ){
Case CommonUtils. FLAG_DOWNLOAD:
MTextView. setText ("Download ended ");
Break;
Case CommonUtils. FLAG_UPDATE:
MTextView. setText ("Update ended ");
Break;
}
}
Note:
1. CommonUtils is a custom tool class, which includes the following two int type constants:

Public static final int FLAG_DOWNLOAD = 1;
Public static final int FLAG_UPDATE = 2;
2. msg is the message object sent by the work thread. The thread code is listed in step 1.
3. If the value of msg. what is CommonUtils. FLAG_DOWNLOAD, the download is complete.
If the value of msg. what is CommonUtils. FLAG_UPDATE, the update is complete.
12.4. Send the Runnalbe object-update the UI
12.4.1. Overview
1. Runnable interface
The source code of this interface is as follows:
Public interface Runnable {
Public void run ();
}
Java rules: a thread must implement the run method in Runnable. The same is true for Android threads. When you view the Android source code of a new Thread, you will find that the internal code also creates a Runnable object and implements the run method.
2. Handler. post () method
The Handler class has a method: post (Runnable r );
Purpose: Send the Runnable object as a parameter to the Message pair column. The source code of the post method is as follows:
Public final boolean post (Runnable r)
{
Return sendMessageDelayed (getPostMessage (r), 0 );
}
The code above shows that the Runnable object r is sent to the Message Queue as the first parameter of the message, and then sent to the main thread for processing by logoff, as shown in-5.
Based on the above principle, the code in Runnable. run can be run in the main thread, so you can write the code to update the UI of the main thread in the Runnable. run method.
12.4.2. Example
Click the button to create a working thread in the event method, and first simulate the download operation in this thread. After the operation is completed, an internal Anonymous class implementing Runnable is sent to the main thread. The Code is as follows:
Public void onClick (View v ){
Switch (v. getId ()){
Case R. id. btnDownload:
// Create a Handler object
Final Handler handler = new Handler ();
// A new working thread simulates the download operation
New Thread (){
Public void run (){
CommonUtils. timeConsuming (5); // simulate the download operation
/* After the download is complete,
* Code the internal Anonymous class of Runable
* As the first parameter in the message, it is sent to the Message pair column,
* The logoff is then handed over to the main thread for execution */
Handler. post (new Runnable (){
@ Override
Public void run (){
MTextView. setText ("download finished ");
}
});
};
}. Start (); // start the working thread
Break;
Case R. id. btnUpdate:
Break;
}
}
12.5.runOnUiThread () sends the Runnable object
12.5.1. Overview
The Activity class provides a runOnUiThread method, which encapsulates the Handler. post method, so it works the same as Handler. post.
12.5.2. Example
Use the runOnUiThread method to send the Runnable object and let the main thread execute the run method in the object. The sample code is as follows:
// A new working thread
New Thread (){
Public void run (){
CommonUtils. timeConsuming (8); // simulate the update operation
// Create an instance with the Runnable interface
Runnable action = new Runnable (){
// Implement the run method, in which you can modify the UI
@ Override
Public void run (){
MTextView. setText ("update finished ");
}
};
// Send the action object to the Message pair column and hand it to the main thread to execute the code in the run Method
RunOnUiThread (action );
};
}. Start (); // start the thread
12.6. View. post () sends the Runnable object-updates the UI
12.6.1. Overview
The View class also provides the method to send a Runnable object to the Message pair column and then hand it over to the main thread by Logoff:
1. Post (Runnable r );
2. postDelayed (Runnable r, long delayMillis );

Purpose: delay the specified time, and then send the r object to the main thread for execution.
12.6.2. Example
@ Override
Public void onClick (final View v ){
Switch (v. getId ()){
Case R. id. download:
New Thread (){
Public void run (){
CommonUtils. timeConsuming (1 );
Runnable action = new Runnable (){
@ Override
Public void run (){
MTextView. setText ("download completed ");
}
};
// V-the current button object. The action object is executed by the main thread with a delay of 1 second.
V. postDelayed (action 1000 );
}
}. Start ();
Break;
Case R. id. update:
New Thread (){
Public void run (){
CommonUtils. timeConsuming (8 );
Runnable action = new Runnable (){
@ Override
Public void run (){
MTextView. setText ("News updated ");
}
};
/V-the current button object, which is sent 3 seconds after being sent. The action object is executed by the main thread.
V. postDelayed (action 3000 );
}
}. Start ();
Break;
12.7.post Summary
12.7.1. Overview
Android provides the post method, which sends the Runnable object (as the first parameter in the message) to the Message pair column, and then the logoff sends the message in the message pair column to the main thread for execution. In this way, you can write the UI modification code in Runnable. run. Note: Do not write time-consuming code in the run method. Time-consuming code should be run in the run method of the worker thread. The following lists the post methods that have been introduced.
1. runOnUiThread (Runnable): This method encapsulates handler. post.
2. View. post (Runnable): run the selected control object and send the Runnable object.
3. Handler. post (Runnable)
4. View. postDelayed (Runnable, long): delayed sending
5. Handler. postDelayed (Runnable, long): delayed sending
12.7.2.Handler.post and runOnUiThread
1. Handler can implement message communication between threads.
2. Handler is more advantageous in terms of code readability and performance (number of objects created.
12.8. AsyncTask updates the UI
12.8.1. Overview
Previously we used a new thread object. Using this anonymous thread method has the following defects:
First, the thread overhead is high. If each task needs to create a thread, the application efficiency will be much lower;
Second, threads cannot be managed. Anonymous threads are not controlled by the program after they are created and started. If many requests are sent, many threads will be started and the system will be overwhelmed. In addition, handler must be introduced to update the UI in the work thread, which makes the Code look very bloated.
To solve this problem, AsyncTask is introduced. AsyncTask is characterized by running tasks outside the main thread, and the callback method is executed in the main thread, which effectively avoids the trouble of using Handler. According to the source code of AsyncTask, AsyncTask uses java. util. the concurrent framework is used to manage threads and task execution. The concurrent framework is a very mature and efficient framework that has been rigorously tested. This shows that AsyncTask is designed to solve the problem of anonymous threads.
AsyncTask is an abstract class. The subclass must implement the abstract method doInBackground (Params... p). In this method, the task is executed, such as connecting to the network to obtain data. Generally, the onPostExecute (Result r) method should also be implemented, because the results that the application cares about are returned in this method.
Tip: AsyncTask must create an instance in the main thread.
AsyncTask defines three generic types: Params, SS, and Result.
(1) input parameters for Params startup task execution, such as the URL of the HTTP request.
(2) percentage of Progress SS background tasks executed.
(3) The Result returned by the background execution task, such as String.
12.8.2. Common Methods
The execution of AsyncTask is divided into four steps. Each step corresponds to a callback method. Note that these methods should not be called by the application. What developers need to do is to implement these methods. These methods are automatically called During task execution.

1. onPreExecute ();
Purpose: call this method before the task is executed. The progress dialog box is displayed here.
2. doInBackground (Params ...);
Purpose: perform time-consuming operations in the background thread. During execution, you can call publicProgress (Progress...) to update the task Progress.
Tip: publicProgress () is equivalent to the Handler. sendmessage () method.
3. onProgressUpdate (Progress ...);
Purpose: This method is executed in the main thread to display the task execution progress.
4. onPostExecute (Result );
Purpose: This method is executed in the main thread, and the result of task execution is returned as a parameter of this method.
12.8.3. Example
Use AsyncTask to implement graph-6. After you click the dwonload button, the simulated download progress is displayed in the progress bar and the percentage of the progress is displayed in the label. Download finised is displayed after the download.
Figure-6a-6b
Public class MainActivity extends Activity implements OnClickListener {
Handler mHandler;
ProgressBar mProgressBar; // declares the progress bar
TextView mTextView; // Tag: displays the percentage of progress and operation results.
@ Override
Public void onCreate (Bundle savedInstanceState ){
Super. onCreate (savedInstanceState );
SetContentView (R. layout. main );
// Instantiate various controls
MProgressBar = (ProgressBar) findViewById (R. id. progressBar );
MTextView = (TextView) findViewById (R. id. tvMessage );
Button btnDownload = (Button) findViewById (R. id. btnDownload );
Button btnUpdate = (Button) findViewById (R. id. btnUpdate );
// Click the event of the Registration button
BtnDownload. setOnClickListener (this );
BtnUpdate. setOnClickListener (this );
}
// Click the time event of the implementation button
@ Override
Public void onClick (View v ){
Switch (v. getId ()){
Case R. id. btnDownload:
// Create an object
MyAsyncTask myAsyncTask = new MyAsyncTask ();
MyAsyncTask.exe cute (null); // executes the task
Break;
Case R. id. btnUpdate:
Break;
}
}
Private class MyAsyncTask extends AsyncTask <URL, Integer, String> {
// Execute in the UI to update the UI
@ Override
Protected void onProgressUpdate (Integer... values ){
MProgressBar. setProgress (values [0]);
If (values [0] <100 ){
MTextView. setText ("progress =" + values [0] + "% ");
}
}
// Execute the time-consuming operation in the current work thread
@ Override
Protected String doInBackground (URL... params ){
For (int I = 0; I <100; I ++ ){
PublishProgress (I + 1); // send a message to onProgressUpdate
Try {
Thread. sleep (100 );
} Catch (InterruptedException e ){
E. printStackTrace ();
}
}
Return "download finished ";
}
// After the doInBackground ends, execute this method. The result is the data returned by the doInBackground method.
@ Override
Protected void onPostExecute (String result ){
MTextView. setText (result );
}
}
}
12.9. Terms for software development
12.9.1 Performance
The more temporary objects, the higher the garbage collection (GC) frequency.
GC occupies CPU and cannot respond to user operations when the CPU is occupied
The user feels that the card affects the user experience.
12.9.2 resource pool
Stores a certain number of objects of the same type. When a program needs to be used, it can be obtained from the resource pool, used completely, and withdrawn from the resource pool.
Wait for the next time to be used.
Example: get the Message object from the resource pool.
Message msg = Message. obtainMessage ();
Tip: If no Message is created before, it is created to the object. The Android system recycles the object at an appropriate time for future use.
Tip: the prerequisite for solving performance problems is that the function cannot be affected.