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

This article mainly explains "how to master the primary, intermediate and advanced questions of Handler". The content of the explanation is simple and clear, and it is easy to learn and understand. Please follow the editor's train of thought to study and learn "how to master the primary, intermediate and advanced questions of Handler".

Handler source code and answers to frequently asked questions

Let's take a look at the official definition:

A Handler allows you to send and process Message and Runnable objects associated with a thread's MessageQueue. Each Handler instance is associated with a single thread and that thread's message queue. When you create a new Handler it is bound to a Looper. It will deliver messages and runnables to that Looper's message queue and execute them on that Looper's thread.

The main idea is that Handler allows you to send Message/Runnable to a thread's message queue (MessageQueue), and each Handler instance is associated with a thread and that thread's message queue. When you create a Handler, you should bind it to a Looper (the main thread has already created a Looper by default, and the child thread needs to create its own Looper), which sends Message/Runnable to the corresponding message queue of the Looper and processes the corresponding Message/Runnable in the thread where the Looper resides. The following picture shows the workflow of Handler.

Handler work flow chart

You can see that in Thread, this conveyor belt of Looper is actually an endless loop. It constantly fetches messages from the message queue MessageQueue, and finally gives them to Handler.dispatchMessage for message distribution, while Handler.sendXXX,Handler.postXXX sends messages to MessageQueue in the message queue. The whole pattern is actually a producer-consumer model, which continuously produces messages, processes messages, and hibernates when there are no messages. MessageQueue is a priority queue made up of a single linked list (all headers are taken, so it is a queue).

As mentioned earlier, when you create a Handler, you should bind to a Looper (binding can also be understood as creating. The main thread has already created a Looper by default, and the child thread needs to create its own Looper), so let's take a look at how it is handled in the main thread:

/ / ActivityThread.java public static void main (String [] args) {Looper.prepareMainLooper (); ActivityThread thread = new ActivityThread (); thread.attach (false, startSeq); if (sMainThreadHandler = = null) {sMainThreadHandler = thread.getHandler () } if (false) {Looper.myLooper () .setMessageLogging (new LogPrinter (Log.DEBUG, "ActivityThread");} / / End of event ActivityThreadMain. Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); Looper.loop (); throw new RuntimeException ("Main thread loop unexpectedly exited");}

You can see that in the main method in ActivityThread, we first call the Looper.prepareMainLooper () method, then get the Handler of the current thread, and finally call Looper.loop (). Let's first take a look at the Looper.prepareMainLooper () method

/ / Looper.java / * * Initialize the current thread as a looper, marking it as an * application's main looper. The main looper for your application * is created by the Android environment, so you should never need * to call this function yourself. See also: {@ link # prepare ()} * / public static void prepareMainLooper () {prepare (false); synchronized (Looper.class) {if (sMainLooper! = null) {throw new IllegalStateException ("The main Looper has already been prepared.");} sMainLooper = myLooper () }} / / prepare private static void prepare (boolean quitAllowed) {if (sThreadLocal.get ()! = null) {throw new RuntimeException ("Only one Looper may be created per thread");} sThreadLocal.set (new Looper (quitAllowed));}

You can see that the Looper of the current thread is created in the Looper.prepareMainLooper () method, and the Looper instance is stored in the thread local variable sThreadLocal (ThreadLocal), that is, each thread has its own Looper. The message queue for the thread is also created when the Looper is created. You can see that prepareMainLooper will determine whether the sMainLooper has a value. If it is called multiple times, an exception will be thrown, so there will only be one Looper and MessageQueue for the main thread. When Looper.prepare () is called in the same child thread, the prepare (true) method is called, and if called multiple times, an exception is thrown that each thread can only have one Looper. To sum up, there is only one Looper and MessageQueue in each thread.

/ / Looper.java private Looper (boolean quitAllowed) {mQueue = new MessageQueue (quitAllowed); mThread = Thread.currentThread ();}

Then take a look at the main thread sMainThreadHandler = thread.getHandler (). What getHandler actually gets is the Handler of mH.

/ / ActivityThread.java final H mH = new H (); @ UnsupportedAppUsage final Handler getHandler () {return mH;}

MH this Handler is the inner class of ActivityThread. By looking at the handMessage method, you can see that this Handler handles messages from the four major components, Application, etc., such as creating Service and binding Service.

/ / ActivityThread.java class H extends Handler {public void handleMessage (Message msg) {if (DEBUG_MESSAGES) Slog.v (TAG, "> handling:" + codeToString (msg.what)); switch (msg.what) {case BIND_APPLICATION: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication") AppBindData data = (AppBindData) msg.obj; handleBindApplication (data); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); break; case EXIT_APPLICATION: if (mInitialApplication! = null) {mInitialApplication.onTerminate () } Looper.myLooper () .quit (); break; case RECEIVER: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, "broadcastReceiveComp"); handleReceiver ((ReceiverData) msg.obj); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER) Break; case CREATE_SERVICE: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceCreate:" + String.valueOf (msg.obj); handleCreateService ((CreateServiceData) msg.obj); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); break Case BIND_SERVICE: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind"); handleBindService ((BindServiceData) msg.obj); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); break Case UNBIND_SERVICE: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceUnbind"); handleUnbindService ((BindServiceData) msg.obj); schedulePurgeIdler (); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); break Case SERVICE_ARGS: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, ("serviceStart:" + String.valueOf (msg.obj); handleServiceArgs ((ServiceArgsData) msg.obj); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); break Case STOP_SERVICE: Trace.traceBegin (Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceStop"); handleStopService ((IBinder) msg.obj); schedulePurgeIdler (); Trace.traceEnd (Trace.TRACE_TAG_ACTIVITY_MANAGER); break Case APPLICATION_INFO_CHANGED: mUpdatingSystemConfig = true; try {handleApplicationInfoChanged ((ApplicationInfo) msg.obj);} finally {mUpdatingSystemConfig = false;} break Case RUN_ISOLATED_ENTRY_POINT: handleRunIsolatedEntryPoint ((String) ((SomeArgs) msg.obj) .arg1, (String []) ((SomeArgs) msg.obj) .arg2); break; case EXECUTE_TRANSACTION: final ClientTransaction transaction = (ClientTransaction) msg.obj; mTransactionExecutor.execute (transaction) If (isSystem ()) {/ / Client transactions inside system process are recycled on the client side / / instead of ClientLifecycleManager to avoid being cleared before this / / message is handled. Transaction.recycle ();} / / TODO (lifecycler): Recycle locally scheduled transactions. Break; case RELAUNCH_ACTIVITY: handleRelaunchActivityLocally ((IBinder) msg.obj); break; case PURGE_RESOURCES: schedulePurgeIdler (); break;} Object obj = msg.obj; if (obj instanceof SomeArgs) {((SomeArgs) obj) .recycle () } if (DEBUG_MESSAGES) Slog.v (TAG, "

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.