"original" Source Angle Analysis Android message mechanism series (V) How--looper works

Last Update:2017-06-18 Source: Internet

Author: User

Developer on Alibaba Coud: Build your first app with APIs, SDKs, and tutorials on the Alibaba Cloud. Read more ＞

ι Copyright Notice: This article for Bo Master original article, without Bo Master permission not Reproduced. Looper is used for message loops in the Android messaging Mechanism. It will keep looping, go to the MessageQueue to see if there is a new message, and if there is a message, process the message immediately, otherwise wait.There is a property in Looper:<pre><pre>Static Final New Threadlocal<looper> ();</pre></pre>This explains what we said earlier that we can achieve looper In-thread access through Threadlocal.In addition, there are two attributes to Note:<pre><pre>Final MessageQueue mqueue; Final Thread mthread;</pre></pre>Let's take a look at the Looper constructor:<pre><pre> Private Looper (boolean quitallowed) { new MessageQueue (quitallowed); = Thread.CurrentThread (); }</pre></pre>In the constructor, a MessageQueue message queue is created and the objects of the current thread are Saved.Next look at the loop method, only after the loop method is called, the message circulatory system really played a role.<pre> /*** Run The message queue in this Thread. Be sure to call * {@link#quit ()} to end of the Loop. */ public Static voidLoop () {FinalLooper me =Mylooper (); if(me = =NULL) { Throw NewRuntimeException ("No Looper; Looper.prepare () wasn ' t called on the This Thread. "); } FinalMessageQueue queue =me.mqueue; //make sure the identity of the the the the The local process,//And keep track of the what, identity token actually is.binder.clearcallingidentity (); Final LongIdent =binder.clearcallingidentity (); for (;;) {Message msg= Queue.next ();//might block if(msg = =NULL) { //No message indicates that the message queue is Quitting. return; } //this must is in a local variable with case a UI event sets the logger FinalPrinter logging =me.mlogging; if(logging! =NULL) {logging.println (">>>>> dispatching to" + msg.target + "" +Msg.callback+ ": " +msg.what); } Final LongTracetag =me.mtracetag; if(tracetag! = 0) {trace.tracebegin (tracetag, msg.target.getTraceName (msg)); } Try{msg.target.dispatchMessage (msg); } finally { if(tracetag! = 0) {trace.traceend (tracetag); } } if(logging! =NULL) {logging.println ("<<<<< finished to" + msg.target + "" +msg.callback); } //make sure that during the course of dispatching the//The identity of the thread wasn ' t Corrupted. Final LongNewident =binder.clearcallingidentity (); if(ident! =Newident) {LOG.WTF (TAG,"Thread identity changed from 0x" + long.tohexstring (ident) + "to 0x" + Lon G.tohexstring (newident) + "while dispatching to" + msg.target.getClass (). getName () + "" + Msg.callback + "what=" +msg.what); } msg.recycleunchecked (); } }</pre>The Mylooper method is called first in the loop method:<pre><pre> /** * Return The Looper object associated with the current Thread. Returns * NULL if the calling thread is not associated with a Looper. */ public Static @Nullable Looper mylooper () { return sthreadlocal.get (); }</pre></pre>The Mylooper method returns the Looper object associated with the current line threads. If the current thread does not have any Looper objects associated with it, the method returns Null.To see the source of the loop method, you can know that when the thread does not have any Looper objects associated with it, The loop method throws a run-time exception, prompting that there is no looper in the current THREADS. To resolve this problem, you can create a Looper object by executing the Looper.prepare () method before the loop method is Called. Continue to look at the source of the loop method, you can see that the method is a dead loop, the only way to jump out of the loop is Queue.next () returns the object is Null. In the previous article, we analyzed that Queue.next () reads the message in messagequeue, and the next () method returns null, stating that there is no message in messagequeue, that is, the messgaequeue called the Quit Method. So when will MessageQueue call the Quit method? Take a look at Looper's quit Method:<pre><pre> public void quit () { mqueue.quit (false);}</pre></pre>And the quitsafely method of Looper:<pre><pre> public void quitsafely () { mqueue.quit (true);}</pre></pre>The Quit method and the Quitsafely method of Looper cause MessageQueue to call the quit method, so it is recommended to call the Looper's quit () method or the Quitsafely () method when Looper is not needed. To avoid an infinite loop of loop methods.To know the difference between Looper's quit method and quitsafely method, Let's look at Messgaequeue's quit Method:<pre> voidQuitBooleanSafe) { if(!Mquitallowed) { Throw NewIllegalStateException ("Main thread not allowed to Quit.")); } synchronized( this) { if(mquitting) {return; } mquitting=true; if(safe) {removeallfuturemessageslocked (); } Else{removeallmessageslocked (); } //We can assume mptr! = 0 because mquitting was previously false.Nativewake (mptr); } }</pre>Secure exit, The removeallfuturemessageslocked () method is called, which sets a flag that will not exit safely until all messages in the message queue have been processed, and quit calls removeallmessageslocked ( ), Exit Directly.Let's look at the loop method below, focusing on this sentence:<pre><pre>Msg.target.dispatchMessage (msg);</pre></pre>In the overview of the Android message mechanism, we have said that target is a property of the message, and its type is handler,msg.target, which is the object that sent the Message. As a result, the message sent by handler is finally given to itself to invoke the DispatchMessage method, but the DispatchMessage method is called in the Looper loop method, So where is the Looper loop method executed? Executed in the same thread as when the handler was Created.Activitythread (main Thread) will initialize looper when it is created, so we can use handler directly in the main thread, when we need to update the ui, we can send the message through handler, and finally we can go back to the main thread to update the UI.In addition to this, Looper provides some other methods, such as the Preparemainlooper method:<pre> /*** Initialize The current thread as a looper, marking it as a * application ' s main looper. The main looper for your application * are created by the Android environment, so we should never need * to call T His function yourself. See Also: {@link#prepare ()}*/ public Static voidpreparemainlooper () {prepare (false); synchronized(Looper.class) { if(smainlooper! =NULL) { Throw NewIllegalStateException ("the main Looper has already been prepared."); } smainlooper=Mylooper (); } }</pre>This method instantiates the current thread as a looper, but is the looper of the main thread. The Android system will create the main thread of the Looper for us, and we do not need to manually call the Method. The essence of the method is also realized by prepare Method.Again like the Getmainlooper method:<pre><pre> /** * Returns The application ' s main looper, which lives in the main thread of the Application. */ public Static Looper getmainlooper () { synchronized (Looper. Class) { return smainlooper; } }</pre></pre>This method allows us to get the looper of the main thread from Anywhere."original" Source Angle Analysis Android message mechanism series (V) How--looper works

This article is an English version of an article which is originally in the Chinese language on aliyun.com and is provided for information purposes only. This website makes no representation or warranty of any kind, either expressed or implied, as to the accuracy, completeness ownership or reliability of the article or any translations thereof. If you have any concerns or complaints relating to the article, please send an email, providing a detailed description of the concern or complaint, to info-contact@alibabacloud.com. A staff member will contact you within 5 working days. Once verified, infringing content will be removed immediately.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

Get Started for Free

Sales Support

1 on 1 presale consultation

Chat Contact Sales
After-Sales Support

24/7 Technical Support 6 Free Tickets per Quarter Faster Response

Open a Ticket
Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.

Learn More