If ui 50 is updated in the Android subthread

This problem has just been encountered.,Follow the source code of Android.,Roughly analyze it.。

Android In order to limit the update UI of sub-threads, a thread inspection mechanism is set up, for example, from the sub-thread pair, it can be seen through the error log, the location of the exception is in, literally, this method is used to check whether the thread that modifies the view is the main thread.

This check method is called in the view's requestLayout(), but requestLayout() is not called in some cases

if(mparent != null){

if (!The only explanation is that one of the above 2 ifs does not match, resulting in the subsequent checkthread() not being called, and the subthread successfully modifies the UI.

This may be in the early stage of the activity creation, the layout or other action initialization has not been completed, resulting in the thread check not occurring, and the specific problem needs to be studied to know.

You can try it, your first case, let the thread sleep for 2 seconds before the new thread changes the textview, and then change the UI and throw an exception.

It's not that the sub-thread can't be finer UI or that the sub-thread in the ui thread can't update the UI directly, what you're creating in OnCreate is a sub-thread that is attached to the main thread. What is created in the button is a child thread that is attached to the UI thread

For case b, you try to create a new thread in the class, and then call it in the setonclicklistener of button, there should be no problem. If it's in the setonclicklistener of the button, it should be considered an internal class.

There are two ways to do this:

By inheriting the thread class and rewriting the run method, multithreading is implemented by inheriting the runnable interface.

It mainly accepts data sent by the sub-thread and uses this data to update the UI with the main thread

The main function of the handler is mainly used for the processing of asynchronous messages

When a message is sent out by the sub-thread, it first enters a message queue (the main thread), and the function that sent the message returns immediately, and the handler in the main thread takes out the messages one by one in the message queue and then processes the messages. This enables cross-threaded UI updates (which are actually done in the main thread).

This mechanism is usually used to handle relatively time-consuming operations, such as time-consuming operations such as accessing the network, reading large files, and time-consuming operations.

In the vernacular a little bit of an introduction to its operation:

Android starts a main thread when the app is launched.

i.e. UI threads), if a time-consuming operation is required at this point, for example:

When reading data over the network, or reading a large local file, you can't put these operations in the main thread, if you put them in the main thread, the interface will freeze (this is why you will be prompted when you directly access the network in the main thread, as we mentioned in the previous article Android main thread can not access the network exception solution).

Non-UI threads in Android cannot operate on the UI, you can perform time-consuming operations on a separate thread, and then update the UI through the handler. Or you can use asynctask.

Take a look at some of the content on this blog and I think you'll be clear!

When an Android program starts running, a separate process is started. By default, all activities or services in this program (service and activity are just two of the components provided by Android, in addition to the content provider and broadcast receiver) will run in this process.

An Android program also has only one process by default, but there can be many threads under a process. Among these threads, there is a thread, which we call UI thread, which is created when the Android program is running, and is the main thread in the process, which is mainly responsible for controlling the display, update and control interaction of the UI interface. At the beginning of the creation of the Android program, a process presented a single-threaded model, and all tasks were run in a single thread.

Therefore, we believe that every function executed by UI Thread should take as little time as possible. Other time-consuming tasks (accessing the network, data, querying the database, etc.) should be performed by sub-threads to avoid blocking the main thread.

So, how does UI Thread work with other threads? The common methods are:

Generate a handler object of the main thread, and act as a listener to allow the child thread to push the message to the message quene of the main thread, so as to trigger the handlermessage() function of the main thread, let the main thread know the status of the child thread, and update the UI on the main thread.