The main thread cannot perform time-consuming operations and the child thread cannot update the UI

There are often problems with Android projects that update the UI after a time-consuming operation in a child thread, and then summarize the updated methods for some of the projects that you have experienced:

Look at the message mechanism in Android before looking at the method:

Reference
Message: Messages that contain the message ID, the message Processing object, and the processed data are queued by MessageQueue and processed by handler.
Handler: Handler, responsible for sending and processing the message. When using handler, you need to implement the Handlemessage (Message msg) method to process a specific message, such as updating the UI.
MessageQueue: Message Queuing, which holds messages sent by handler and executes according to FIFO rules. Of course, storing a message is not a meaningful preservation, but rather a concatenation of the message in the form of a linked list, waiting for the looper to be extracted.
Looper: The message pump continuously extracts message execution from the MessageQueue. Therefore, a MessageQueue needs a looper.
Thread: Threads that are responsible for dispatching the entire message loop, that is, the execution site of the message loop.

Unfamiliar friends can refer to this document:
Android Knowledge Grooming: The handler:http://gqdy365.iteye.com/blog/2148925 of message mechanism
Android Knowledge Grooming: The looper:http://gqdy365.iteye.com/blog/2137494 of message mechanism

The following principle is based on the above-mentioned Update method:
Method One: With handler

1, the main thread defined handler:

Java code

2. Handler Mhandler = new Handler () {
6. @Override
8. public void Handlemessage (Message msg) {
10. super.handlemessage (msg);
12. switch (msg.what) {
14. Case 0:
16. //Finish the main interface update, get the data
18. String data = (string) msg.obj;
22. Updateweather ();
24. Textview.settext (data);
26. Break ;
28. Default:
30. Break ;
32. }
34. }
38. };

2, the child thread sends the message, notifies handler to complete the UI update:

Java code

2. Private void Updateweather () {
8. New Thread (new Runnable () {
12. @Override
14. public Void Run () {
16. //Time consuming operation, send message to handler after completion, complete UI update;
18. Mhandler.sendemptymessage (0);
22. //Need data transfer, using the following method;
24. Message msg =new Message ();
26. Msg.obj = "Data"; Can be the basic type, can be an object, can be a list, map, etc.;
28. Mhandler.sendmessage (msg);
30. }
34. }). Start ();
38. }

The handler object of method one must be defined in the main thread, if multiple classes are called directly to each other, it is not very convenient to pass the Content object or call through the interface;

Method Two: Update with the Runonuithread method of activity object
Update the UI with the Runonuithread () method in a child thread:

Java code

2. New Thread () {
4. public Void Run () {
6. //Here is a time-consuming operation to update the UI after completion;
8. Runonuithread (new Runnable () {
12. @Override
14. public Void Run () {
16. //Update UI
18. Imageview.setimagebitmap (bitmap);
20. }
24. });
26. }
28. }.start ();

If it is in a non-contextual class (Activity), it can be invoked by passing the context;

Java code

2. Activity activity = (activity) imageview.getcontext ();
4. Activity.runonuithread (new Runnable () {
8. @Override
10. public Void Run () {
12. Imageview.setimagebitmap (bitmap);
14. }
16. });

This method is more flexible to use, but if the thread is defined elsewhere, the activity object needs to be passed;

Method Three: View.post (Runnable R)

Java code

2. Imageview.post (new Runnable () {
6. @Override
8. public Void Run () {
10. Imageview.setimagebitmap (bitmap);
12. }
16. });

The main thread cannot perform time-consuming operations and the child thread cannot update the UI