Android线程间通信机制——深入理解 Looper、Handler、Message
在Android中,经常使用Handler来实现线程间通信,必然要理解Looper , Handler , Message和MessageQueue的使用和原理,下面说一下Looper , Handler , Message有什么关系?下面从源码角度介绍3者关系,再给出一个结论。
1、导论
Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。
什么叫异步消息处理线程呢?
异步消息处理线程启动后会进入一个无限的循环体之中,每循环一次,从其内部的消息队列中取出一个消息,然后回调相应的消息处理函数,执行完成一个消息后则继续循环。若消息队列为空,线程则会阻塞等待。那么和Handler 、 Looper 、Message有啥对应关系?
其实Looper负责的就是创建一个MessageQueue,然后进入一个无限循环体不断从该MessageQueue中读取消息,而消息的创建者就是一个或多个Handler 。
2、 源码分析
1、Looper
对于Looper主要是prepare()和loop()两个方法。首先看prepare()方法
[java] view plain copy
- publicstaticfinalvoidprepare(){
- if(sThreadLocal.get()!=null){
- thrownewRuntimeException("OnlyoneLoopermaybecreatedperthread");
- }
- sThreadLocal.set(newLooper(true));
- }
sThreadLocal是一个ThreadLocal对象,可以在一个线程中存储变量。可以看到,在第5行,将一个Looper的实例放入了ThreadLocal,并且2-4行判断了sThreadLocal是否为null,否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次,同时也保证了一个线程中只有一个Looper实例
[java] view plain copy
- privateLooper(booleanquitAllowed){
- mQueue=newMessageQueue(quitAllowed);
- mRun=true;
- mThread=Thread.currentThread();
- }
然后我们看loop()方法:
[java] view plain copy
- publicstaticvoidloop(){
- finalLooperme=myLooper();
- if(me==null){
- thrownewRuntimeException("NoLooper;Looper.prepare()wasn'tcalledonthisthread.");
- }
- finalMessageQueuequeue=me.mQueue;
- //Makesuretheidentityofthisthreadisthatofthelocalprocess,
- //andkeeptrackofwhatthatidentitytokenactuallyis.
- Binder.clearCallingIdentity();
- finallongident=Binder.clearCallingIdentity();
- for(;;){
- Messagemsg=queue.next();//mightblock
- if(msg==null){
- //Nomessageindicatesthatthemessagequeueisquitting.
- return;
- }
- //Thismustbeinalocalvariable,incaseaUIeventsetsthelogger
- Printerlogging=me.mLogging;
- if(logging!=null){
- logging.println(">>>>>Dispatchingto"+msg.target+""+
- msg.callback+":"+msg.what);
- }
- msg.target.dispatchMessage(msg);
- if(logging!=null){
- logging.println("<<<<<Finishedto"+msg.target+""+msg.callback);
- }
- //Makesurethatduringthecourseofdispatchingthe
- //identityofthethreadwasn'tcorrupted.
- finallongnewIdent=Binder.clearCallingIdentity();
- if(ident!=newIdent){
- Log.wtf(TAG,"Threadidentitychangedfrom0x"
- +Long.toHexString(ident)+"to0x"
- +Long.toHexString(newIdent)+"whiledispatchingto"
- +msg.target.getClass().getName()+""
- +msg.callback+"what="+msg.what);
- }
- msg.recycle();
- }
- }
public static Looper myLooper() {
return sThreadLocal.get();
}
方法直接返回了sThreadLocal存储的Looper实例,如果me为null则抛出异常,也就是说looper方法必须在prepare方法之后运行。
第6行:拿到该looper实例中的mQueue(消息队列)
13到45行:就进入了我们所说的无限循环。
14行:取出一条消息,如果没有消息则阻塞。
27行:使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。Msg的target是什么呢?其实就是handler对象,下面会进行分析。
44行:释放消息占据的资源。
Looper主要作用:
2、 loop()方法,不断从MessageQueue中去取消息,交给消息的target属性的dispatchMessage去处理。
好了,我们的异步消息处理线程已经有了消息队列(MessageQueue),也有了在无限循环体中取出消息的哥们,现在缺的就是发送消息的对象了,于是乎:Handler登场了。
2、Handler
使用Handler之前,我们都是初始化一个实例,比如用于更新UI线程,我们会在声明的时候直接初始化,或者在onCreate中初始化Handler实例。所以我们首先看Handler的构造方法,看其如何与MessageQueue联系上的,它在子线程中发送的消息(一般发送消息都在非UI线程)怎么发送到MessageQueue中的。[java] view plain copy
- publicHandler(){
- this(null,false);
- }
- publicHandler(Callbackcallback,booleanasync){
- 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());
- }
- }
- mLooper=Looper.myLooper();
- if(mLooper==null){
- thrownewRuntimeException(
- "Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare()");
- }
- mQueue=mLooper.mQueue;
- mCallback=callback;
- mAsynchronous=async;
- }
14行:通过Looper.myLooper()获取了当前线程保存的Looper实例,然后在19行又获取了这个Looper实例中保存的MessageQueue(消息队列),这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。
然后看我们最常用的sendMessage方法
[java] view plain copy
- publicfinalbooleansendMessage(Messagemsg)
- {
- returnsendMessageDelayed(msg,0);
- }
- publicfinalbooleansendEmptyMessageDelayed(intwhat,longdelayMillis){
- Messagemsg=Message.obtain();
- msg.what=what;
- returnsendMessageDelayed(msg,delayMillis);
- }
- publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis)
- {
- if(delayMillis<0){
- delayMillis=0;
- }
- returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis);
- }
- publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
- MessageQueuequeue=mQueue;
- if(queue==null){
- RuntimeExceptione=newRuntimeException(
- this+"sendMessageAtTime()calledwithnomQueue");
- Log.w("Looper",e.getMessage(),e);
- returnfalse;
- }
- returnenqueueMessage(queue,msg,uptimeMillis);
- }
最后调用了sendMessageAtTime,在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法,我们再来看看此方法:
[java] view plain copy
- privatebooleanenqueueMessage(MessageQueuequeue,Messagemsg,longuptimeMillis){
- msg.target=this;
- if(mAsynchronous){
- msg.setAsynchronous(true);
- }
- returnqueue.enqueueMessage(msg,uptimeMillis);
- }
enqueueMessage中首先为meg.target赋值为this,【如果大家还记得Looper的loop方法会取出每个msg然后交给msg,target.dispatchMessage(msg)去处理消息】,也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法,也就是说handler发出的消息,最终会保存到消息队列中去。
现在已经很清楚了Looper会调用prepare()和loop()方法,在当前执行的线程中保存一个Looper实例,这个实例会保存一个MessageQueue对象,然后当前线程进入一个无限循环中去,不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法,下面我们赶快去看一看这个方法:
[java] view plain copy
- publicvoiddispatchMessage(Messagemsg){
- if(msg.callback!=null){
- handleCallback(msg);
- }else{
- if(mCallback!=null){
- if(mCallback.handleMessage(msg)){
- return;
- }
- }
- handleMessage(msg);
- }
- }
[java] view plain copy
- /**
- *Subclassesmustimplementthistoreceivemessages.
- */
- publicvoidhandleMessage(Messagemsg){
- }
例如:
[java] view plain copy
- privateHandlermHandler=newHandler()
- {
- publicvoidhandleMessage(android.os.Messagemsg)
- {
- switch(msg.what)
- {
- casevalue:
- break;
- default:
- break;
- }
- };
- };
到此,这个流程已经解释完毕,让我们首先总结一下
1、首先Looper.prepare()在本线程中保存一个Looper实例,然后该实例中保存一个MessageQueue对象;因为Looper.prepare()在一个线程中只能调用一次,所以MessageQueue在一个线程中只会存在一个。
2、Looper.loop()会让当前线程进入一个无限循环,不端从MessageQueue的实例中读取消息,然后回调msg.target.dispatchMessage(msg)方法。
3、Handler的构造方法,会首先得到当前线程中保存的Looper实例,进而与Looper实例中的MessageQueue想关联。
4、Handler的sendMessage方法,会给msg的target赋值为handler自身,然后加入MessageQueue中。
5、在构造Handler实例时,我们会重写handleMessage方法,也就是msg.target.dispatchMessage(msg)最终调用的方法。
好了,总结完成,大家可能还会问,那么在Activity中,我们并没有显示的调用Looper.prepare()和Looper.loop()方法,为啥Handler可以成功创建呢,这是因为在Activity的启动代码中,已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。
3、Handler 的post方法
下面说一下Handler的post方法创建的线程和UI线程有什么关系?这里需要说明,有时候为了方便,我们会直接写如下代码:
[java] view plain copy
- mHandler.post(newRunnable()
- {
- @Override
- publicvoidrun()
- {
- Log.e("TAG",Thread.currentThread().getName());
- mTxt.setText("yoxi");
- }
- });
[java] view plain copy
- publicfinalbooleanpost(Runnabler)
- {
- returnsendMessageDelayed(getPostMessage(r),0);
- }
- privatestaticMessagegetPostMessage(Runnabler){
- Messagem=Message.obtain();
- m.callback=r;
- returnm;
- }
可以看到,在getPostMessage中,得到了一个Message对象,然后将我们创建的Runable对象作为callback属性,赋值给了此message.
注:产生一个Message对象,可以new ,也可以使用Message.obtain()方法;两者都可以,但是更建议使用obtain方法,因为Message内部维护了一个Message池用于Message的复用,避免使用new 重新分配内存。
- publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis)
- {
- if(delayMillis<0){
- delayMillis=0;
- }
- returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis);
- }
- publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
- MessageQueuequeue=mQueue;
- if(queue==null){
- RuntimeExceptione=newRuntimeException(
- this+"sendMessageAtTime()calledwithnomQueue");
- Log.w("Looper",e.getMessage(),e);
- returnfalse;
- }
- returnenqueueMessage(queue,msg,uptimeMillis);
- }
可以看到,这里msg的callback和target都有值,那么会执行哪个呢?
其实上面已经贴过代码,就是dispatchMessage方法:
[java] view plain copy
- publicvoiddispatchMessage(Messagemsg){
- if(msg.callback!=null){
- handleCallback(msg);
- }else{
- if(mCallback!=null){
- if(mCallback.handleMessage(msg)){
- return;
- }
- }
- handleMessage(msg);
- }
- }
通过以上的介绍,关于Looper , Handler , Message 这三者关系上面已经叙述的非常清楚了。下面通过一张图来了解一下流程:
希望图片可以更好的帮助大家的记忆~~
4、补充
其实Handler不仅可以更新UI,你完全可以在一个子线程中Thread线程,去创建一个Handler,然后,使用这个handler实例在任何其他线程中发送消息,最终处理消息的代码都会在你创建Handler实例的线程中运行。
[java] view plain copy
- newThread()
- {
- privateHandlerhandler;
- publicvoidrun()
- {
- Looper.prepare();
- handler=newHandler()
- {
- publicvoidhandleMessage(android.os.Messagemsg)
- {
- Log.e("TAG",Thread.currentThread().getName());
- };
- };
- Looper.loop();
- }
最后,Android框架的设计思想有很多方面是值得我们借鉴的,不仅给我们提供了异步消息处理机制来更好的实现UI的更新,实现子线程与主线程交互,或者子线程与子线程之间进行通信。我们在开发中,一定要深入理解各种机制的原理,还可以把源码的编程思想应用到平时得Android项目开发中。
更多相关文章
- 【Android(安卓)Dev Guide - 03】 - Content Providers
- Android(安卓)TextView使用HTML处理字体样式、显示图片等
- Android文件系统的提取方法(一)
- [Android][Android(安卓)Studio] *.jar 与 *.aar 的生成与*.aar
- android 登陆、提交数据或加载数据时提示页面
- Testing和Instrumentation
- Android(安卓)推送通知指南
- 浅谈Java中Collections.sort对List排序的两种方法
- Python list sort方法的具体使用