Shulou(Shulou.com)06/02 Report--

This article shows you what is the relationship between synchronization and asynchronism in Android. The content is concise and easy to understand, which will definitely brighten your eyes. I hope you can get something through the detailed introduction of this article.

In android, only the UI thread can refresh the interface, but not the other sub-threads, so the sub-thread needs to refresh and modify the interface through communication messages.

There are two ways to do this:

AsyncTask,Handle

AsyncTask

Simple threads for asynchronous communication provided by android

There are four main implementation interfaces:

OnPreExecute (), which will be called by the UI thread before performing the actual background operation. You can do some preparatory work in this method, such as displaying a progress bar on the interface, or instantiating some controls, which does not have to be implemented.

DoInBackground (Params...), which will be executed immediately after the execution of the onPreExecute method, which runs in the background thread. Here will be mainly responsible for performing those time-consuming background processing work. You can call the publishProgress method to update the real-time task progress. This method is abstract and must be implemented by subclasses.

OnProgressUpdate (Progress...), after the publishProgress method is called, the UI thread will call this method to show the progress of the task on the interface, such as through a progress bar.

OnPostExecute (Result), after the doInBackground execution is completed, the onPostExecute method will be called by the UI thread, and the background calculation result will be passed to the UI thread through this method and displayed to the user on the interface.

OnCancelled (), which is called when the user cancels the thread operation. Called when onCancelled () is called in the main thread.

Call attention

1) an instance of Task must be created in the UI thread

2) the execute method must be called in the UI thread

3) do not manually call onPreExecute (), onPostExecute (Result), doInBackground (Params...), onProgressUpdate (Progress...) These methods need to be called by instantiating the task in the UI thread.

4) the task can only be executed once, otherwise an exception will occur when it is called multiple times.

5) the return value of the doInBackground method must correspond to the parameters of onPostExecute. These two parameters are specified in the list of generic parameters declared by AsyncTask. The first is the parameter accepted by doInBackground, the second is the parameter that shows the progress, and the third is the parameter returned by doInBackground and passed in by onPostExecute.

You can see that this thread has a secondary thread's interface to handle doInBackground, and a UI thread's interface to handle onProgressUpdate, which can be passed in generic parameters when the thread is started.

Handler

The Handler class can be seen as a utility class for inserting messages into the message queue. Automatically binds the calling thread Looper when instantiated and executes in that thread when the message is processed. Taking advantage of this feature, the secondary thread sends the message and processes it in the main thread after receiving the message, thus achieving the communication between the main thread and the secondary thread.

It can be understood this way in Android, because in android you can use the UI interface as the main thread, you can't always download just because you download something, the user experience is not good, and it is not allowed by google, so you click on the download to start the child thread to download, you can read what the phone page should see, and then send a message to handler to update the UI. Display or pop up a downloaded message on your phone interface. You don't know if you don't need handler to download it, so you have to read it for yourself. Handler and Thread: child threads cannot update UI, so after opening child threads with Thread, if you need to update UI, update UI through Handler.

While in AsyncTask:

DoInBackground (Params …) Belong to child threads, background execution, more time-consuming operations can be placed here. Note that you cannot directly manipulate UI here. This method is executed in the background thread, and it usually takes a long time to complete the main work of the task. You can call publicProgress (Progress …) during execution. To update the progress of the task.

OnPostExecute (Result) is equivalent to the way Handler handles UI, in which you can use the result processing operation UI obtained in doInBackground. This method is executed in the main thread, and the result of task execution is returned as a parameter to this method.

The looper class is a class that encapsulates message loops and message queues.

(1) the Looper class is used to open a message loop for a thread.

By default, new threads in android do not turn on message loops. (except for the main thread, the main thread system automatically creates a Looper object for it and starts the message loop. )

The Looper object stores messages and events through MessageQueue. A thread can have only one Looper, corresponding to one MessageQueue.

(2) it usually interacts with Looper through the Handler object. Handler can be thought of as an interface for Looper to send messages to a specified Looper and define processing methods.

By default, Handler is bound to the Looper of the thread in which it is defined. For example, if Handler is defined in the main thread, it is bound to the Looper of the main thread.

MainHandler = new Handler () is equivalent to new Handler (Looper.myLooper ()).

Looper.myLooper (): gets the looper object of the current process, similar to the Looper.getMainLooper () used to get the Looper object of the main thread.

(3) directly new Handler () in a non-main thread will report the following error:

E/AndroidRuntime (6173): Uncaught handler: thread Thread-8 exiting due to uncaught exception

E/AndroidRuntime (6173): java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare ()

The reason is that the Looper object is not created by default in the non-main thread, so you need to call Looper.prepare () to enable Looper first.

(4) Looper.loop (); get Looper to work, fetch messages from the message queue and process messages.

Note: code written after Looper.loop () will not be executed. There should be a loop inside this function. When mHandler.getLooper (). Quit () is called, the loop will abort and the subsequent code will run.

(5) based on the above knowledge, the main thread can be realized to send messages to child threads (non-main threads).

Declare the mHandler in the following example as a class member and send a message through mHandler on the main thread.

To sum up, it is generally bound to the handler of the main thread to achieve the purpose of communication and send messages in the secondary thread. To create a binding handler in a sub-thread, you must first create a looper for the sub-thread, which has achieved the purpose of sending messages in a loop. There are two ways to achieve this:

1. Through two classes of handler+Looper.

2, through the HandlerThread class, which is provided by android using Looper and Handler inheritance Thread to complete.

The above is what is the relationship between synchronization and asynchronism in Android. Have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserve, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.