Android消息处理机制Looper和Handler详解
Message:消息,其中包含了消息ID,消息处理对象以及处理的数据等,由MessageQueue统一列队,终由Handler处理。 Handler:处理者,负责Message的发送及处理。使用Handler时,需要实现handleMessage(Messagemsg)方法来对特定的Message进行处理,例如更新UI等。 MessageQueue:消息队列,用来存放Handler发送过来的消息,并按照FIFO规则执行。当然,存放Message并非实际意义的保存,而是将Message以链表的方式串联起来的,等待Looper的抽取。 Looper:消息泵,不断地从MessageQueue中抽取Message执行。因此,一个MessageQueue需要一个Looper。 Thread:线程,负责调度整个消息循环,即消息循环的执行场所。
Android系统的消息队列和消息循环都是针对具体线程的,一个线程可以存在(当然也可以不存在)一个消息队列和一个消息循环(Looper),特定线程的消息只能分发给本线程,不能进行跨线程,跨进程通讯。但是创建的工作线程默认是没有消息循环和消息队列的,如果想让该线程具有消息队列和消息循环,需要在线程中首先调用Looper.prepare()来创建消息队列,然后调用Looper.loop()进入消息循环。如下例所示:
LooperThreadThread{ HandlermHandler; run(){ Looper.prepare(); mHandler=Handler(){ handleMessage(Messagemsg){ } }; Looper.loop(); } }
//Looper类分析
//没找到合适的分析代码的办法,只能这么来了。每个重要行的上面都会加上注释
//功能方面的代码会在代码前加上一段分析
publicclassLooper{ //static变量,判断是否打印调试信息。 privatestaticfinalbooleanDEBUG=false; privatestaticfinalbooleanlocalLOGV=DEBUG?Config.LOGD:Config.LOGV; //sThreadLocal.get()willreturnnullunlessyou'vecalledprepare(). //线程本地存储功能的封装,TLS,threadlocalstorage,什么意思呢?因为存储要么在栈上,例如函数内定义的内部变量。要么在堆上,例如new或者malloc出来的东西 //但是现在的系统比如Linux和windows都提供了线程本地存储空间,也就是这个存储空间是和线程相关的,一个线程内有一个内部存储空间,这样的话我把线程相关的东西就存储到 //这个线程的TLS中,就不用放在堆上而进行同步操作了。 privatestaticfinalThreadLocalsThreadLocal=newThreadLocal(); //消息队列,MessageQueue,看名字就知道是个queue.. finalMessageQueuemQueue; volatilebooleanmRun; //和本looper相关的那个线程,初始化为null ThreadmThread; privatePrintermLogging=null; //static变量,代表一个UIProcess(也可能是service吧,这里默认就是UI)的主线程 privatestaticLoopermMainLooper=null; /**Initializethecurrentthreadasalooper. *Thisgivesyouachancetocreatehandlersthatthenreference *thislooper,beforeactuallystartingtheloop.Besuretocall *{@link#loop()}aftercallingthismethod,andenditbycalling *{@link#quit()}. */ //往TLS中设上这个Looper对象的,如果这个线程已经设过了looper的话就会报错 //这说明,一个线程只能设一个looper publicstaticfinalvoidprepare(){ if(sThreadLocal.get()!=null){ thrownewRuntimeException("OnlyoneLoopermaybecreatedperthread"); } sThreadLocal.set(newLooper()); } /**Initializethecurrentthreadasalooper,markingitasanapplication'smain *looper.ThemainlooperforyourapplicationiscreatedbytheAndroidenvironment, *soyoushouldneverneedtocallthisfunctionyourself. *{@link#prepare()} */ //由framework设置的UI程序的主消息循环,注意,这个主消息循环是不会主动退出的 // publicstaticfinalvoidprepareMainLooper(){ prepare(); setMainLooper(myLooper()); //判断主消息循环是否能退出.... //通过quit函数向looper发出退出申请 if(Process.supportsProcesses()){ myLooper().mQueue.mQuitAllowed=false; } } privatesynchronizedstaticvoidsetMainLooper(Looperlooper){ mMainLooper=looper; } /**Returnstheapplication'smainlooper,whichlivesinthemainthreadoftheapplication. */ publicsynchronizedstaticfinalLoopergetMainLooper(){ returnmMainLooper; } /** *Runthemessagequeueinthisthread.Besuretocall *{@link#quit()}toendtheloop. */ //消息循环,整个程序就在这里while了。 //这个是static函数喔! publicstaticfinalvoidloop(){ Looperme=myLooper();//从该线程中取出对应的looper对象 MessageQueuequeue=me.mQueue;//取消息队列对象... while(true){ Messagemsg=queue.next();//mightblock取消息队列中的一个待处理消息.. //if(!me.mRun){//是否需要退出?mRun是个volatile变量,跨线程同步的,应该是有地方设置它。 //break; //} if(msg!=null){ if(msg.target==null){ //Notargetisamagicidentifierforthequitmessage. return; } if(me.mLogging!=null)me.mLogging.println( ">>>>>Dispatchingto"+msg.target+"" +msg.callback+":"+msg.what ); msg.target.dispatchMessage(msg); if(me.mLogging!=null)me.mLogging.println( "<<<<<Finishedto"+msg.target+"" +msg.callback); msg.recycle(); } } } /** *ReturntheLooperobjectassociatedwiththecurrentthread.Returns *nullifthecallingthreadisnotassociatedwithaLooper. */ //返回和线程相关的looper publicstaticfinalLoopermyLooper(){ return(Looper)sThreadLocal.get(); } /** *ControlloggingofmessagesastheyareprocessedbythisLooper.If *enabled,alogmessagewillbewrittento<var>printer</var> *atthebeginningandendingofeachmessagedispatch,identifyingthe *targetHandlerandmessagecontents. * *@paramprinterAPrinterobjectthatwillreceivelogmessages,or *nulltodisablemessagelogging. */ //设置调试输出对象,looper循环的时候会打印相关信息,用来调试用最好了。 publicvoidsetMessageLogging(Printerprinter){ mLogging=printer; } /** *Returnthe{@linkMessageQueue}objectassociatedwiththecurrent *thread.ThismustbecalledfromathreadrunningaLooper,ora *NullPointerExceptionwillbethrown. */ publicstaticfinalMessageQueuemyQueue(){ returnmyLooper().mQueue; } //创建一个新的looper对象, //内部分配一个消息队列,设置mRun为true privateLooper(){ mQueue=newMessageQueue(); mRun=true; mThread=Thread.currentThread(); } publicvoidquit(){ Messagemsg=Message.obtain(); //NOTE:Byenqueueingdirectlyintothemessagequeue,the //messageisleftwithanulltarget.Thisishowweknowitis //aquitmessage. mQueue.enqueueMessage(msg,0); } /** *ReturntheThreadassociatedwiththisLooper. */ publicThreadgetThread(){ returnmThread; } //后面就简单了,打印,异常定义等。 publicvoiddump(Printerpw,Stringprefix){ pw.println(prefix+this); pw.println(prefix+"mRun="+mRun); pw.println(prefix+"mThread="+mThread); pw.println(prefix+"mQueue="+((mQueue!=null)?mQueue:"(null")); if(mQueue!=null){ synchronized(mQueue){ Messagemsg=mQueue.mMessages; intn=0; while(msg!=null){ pw.println(prefix+"Message"+n+":"+msg); n++; msg=msg.next; } pw.println(prefix+"(Totalmessages:"+n+")"); } } } publicStringtoString(){ return"Looper{" +Integer.toHexString(System.identityHashCode(this)) +"}"; } staticclassHandlerExceptionextendsException{ HandlerException(Messagemessage,Throwablecause){ super(createMessage(cause),cause); } staticStringcreateMessage(Throwablecause){ StringcauseMsg=cause.getMessage(); if(causeMsg==null){ causeMsg=cause.toString(); } returncauseMsg; } } }
那怎么往这个消息队列中发送消息呢??调用looper的static函数myQueue可以获得消息队列,这样你就可用自己往里边插入消息了。不过这种方法比较麻烦,这个时候handler类就发挥作用了。先来看看handler的代码,就明白了。
classHandler{ .......... //handler默认构造函数 publicHandler(){ //这个if是干嘛用的暂时还不明白,涉及到java的深层次的内容了应该 if(FIND_POTENTIAL_LEAKS){ finalClass<?extendsHandler>klass=getClass(); if((klass.isAnonymousClass()||klass.isMemberClass()||klass.isLocalClass())&& (klass.getModifiers()&Modifier.STATIC)==0){ Log.w(TAG,"ThefollowingHandlerclassshouldbestaticorleaksmightoccur:"+ klass.getCanonicalName()); } } //获取本线程的looper对象 //如果本线程还没有设置looper,这回抛异常 mLooper=Looper.myLooper(); if(mLooper==null){ thrownewRuntimeException( "Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare()"); } //无耻啊,直接把looper的queue和自己的queue搞成一个了 //这样的话,我通过handler的封装机制加消息的话,就相当于直接加到了looper的消息队列中去了 mQueue=mLooper.mQueue; mCallback=null; } //还有好几种构造函数,一个是带callback的,一个是带looper的 //由外部设置looper publicHandler(Looperlooper){ mLooper=looper; mQueue=looper.mQueue; mCallback=null; } //带callback的,一个handler可以设置一个callback。如果有callback的话, //凡是发到通过这个handler发送的消息,都有callback处理,相当于一个总的集中处理 //待会看dispatchMessage的时候再分析 publicHandler(Looperlooper,Callbackcallback){ mLooper=looper; mQueue=looper.mQueue; mCallback=callback; } // //通过handler发送消息 //调用了内部的一个sendMessageDelayed publicfinalbooleansendMessage(Messagemsg) { returnsendMessageDelayed(msg,0); } //FT,又封装了一层,这回是调用sendMessageAtTime了 //因为延时时间是基于当前调用时间的,所以需要获得绝对时间传递给sendMessageAtTime publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis) { if(delayMillis<0){ delayMillis=0; } returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis); } publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis) { booleansent=false; MessageQueuequeue=mQueue; if(queue!=null){ //把消息的target设置为自己,然后加入到消息队列中 //对于队列这种数据结构来说,操作比较简单了 msg.target=this; sent=queue.enqueueMessage(msg,uptimeMillis); } else{ RuntimeExceptione=newRuntimeException( this+"sendMessageAtTime()calledwithnomQueue"); Log.w("Looper",e.getMessage(),e); } returnsent; } //还记得looper中的那个消息循环处理吗 //从消息队列中得到一个消息后,会调用它的target的dispatchMesage函数 //message的target已经设置为handler了,所以 //最后会转到handler的msg处理上来 //这里有个处理流程的问题 publicvoiddispatchMessage(Messagemsg){ //如果msg本身设置了callback,则直接交给这个callback处理了 if(msg.callback!=null){ handleCallback(msg); }else{ //如果该handler的callback有的话,则交给这个callback处理了---相当于集中处理 if(mCallback!=null){ if(mCallback.handleMessage(msg)){ return; } } //否则交给派生处理,基类默认处理是什么都不干 handleMessage(msg); } } .......... }
生成
Messagemsg=mHandler.obtainMessage(); msg.what=what; msg.sendToTarget();
发送
MessageQueuequeue=mQueue; if(queue!=null){ msg.target=this; sent=queue.enqueueMessage(msg,uptimeMillis); }
在Handler.java的sendMessageAtTime(Messagemsg,longuptimeMillis)方法中,我们看到,它找到它所引用的MessageQueue,然后将Message的target设定成自己(目的是为了在处理消息环节,Message能找到正确的Handler),再将这个Message纳入到消息队列中。
抽取
Looperme=myLooper(); MessageQueuequeue=me.mQueue; while(true){ Messagemsg=queue.next();//mightblock if(msg!=null){ if(msg.target==null){ //Notargetisamagicidentifierforthequitmessage. return; } msg.target.dispatchMessage(msg); msg.recycle(); } }
在Looper.java的loop()函数里,我们看到,这里有一个死循环,不断地从MessageQueue中获取下一个(next方法)Message,然后通过Message中携带的target信息,交由正确的Handler处理(dispatchMessage方法)。
处理
if(msg.callback!=null){ handleCallback(msg); }else{ if(mCallback!=null){ if(mCallback.handleMessage(msg)){ return; } } handleMessage(msg); }
在Handler.java的dispatchMessage(Messagemsg)方法里,其中的一个分支就是调用handleMessage方法来处理这条Message,而这也正是我们在职责处描述使用Handler时需要实现handleMessage(Messagemsg)的原因。
至于dispatchMessage方法中的另外一个分支,我将会在后面的内容中说明。
至此,我们看到,一个Message经由Handler的发送,MessageQueue的入队,Looper的抽取,又再一次地回到Handler的怀抱。而绕的这一圈,也正好帮助我们将同步操作变成了异步操作。
3)剩下的部分,我们将讨论一下Handler所处的线程及更新UI的方式。
在主线程(UI线程)里,如果创建Handler时不传入Looper对象,那么将直接使用主线程(UI线程)的Looper对象(系统已经帮我们创建了);在其它线程里,如果创建Handler时不传入Looper对象,那么,这个Handler将不能接收处理消息。在这种情况下,通用的作法是:
classLooperThreadextendsThread{ publicHandlermHandler; publicvoidrun(){ Looper.prepare(); mHandler=newHandler(){ publicvoidhandleMessage(Messagemsg){ //processincomingmessageshere } }; Looper.loop(); } }
在创建Handler之前,为该线程准备好一个Looper(Looper.prepare),然后让这个Looper跑起来(Looper.loop),抽取Message,这样,Handler才能正常工作。
因此,Handler处理消息总是在创建Handler的线程里运行。而我们的消息处理中,不乏更新UI的操作,不正确的线程直接更新UI将引发异常。因此,需要时刻关心Handler在哪个线程里创建的。
如何更新UI才能不出异常呢?SDK告诉我们,有以下4种方式可以从其它线程访问UI线程:
· Activity.runOnUiThread(Runnable)
· View.post(Runnable)
· View.postDelayed(Runnable,long)
· Handler
其中,重点说一下的是View.post(Runnable)方法。在post(Runnableaction)方法里,View获得当前线程(即UI线程)的Handler,然后将action对象post到Handler里。在Handler里,它将传递过来的action对象包装成一个Message(Message的callback为action),然后将其投入UI线程的消息循环中。在Handler再次处理该Message时,有一条分支(未解释的那条)就是为它所设,直接调用runnable的run方法。而此时,已经路由到UI线程里,因此,我们可以毫无顾虑的来更新UI。
4)几点小结
· Handler的处理过程运行在创建Handler的线程里
· 一个Looper对应一个MessageQueue
· 一个线程对应一个Looper
· 一个Looper可以对应多个Handler
· 不确定当前线程时,更新UI时尽量调用post方法