深入Android的消息机制源码详解HandlerMessageQueue与Looper关系.docx
《深入Android的消息机制源码详解HandlerMessageQueue与Looper关系.docx》由会员分享，可在线阅读，更多相关《深入Android的消息机制源码详解HandlerMessageQueue与Looper关系.docx（16页珍藏版）》请在冰豆网上搜索。
深入Android的消息机制源码详解HandlerMessageQueue与Looper关系
深入Android的消息机制源码详解～Handler,MessageQueue与Looper关系
一说到Android的消息机制，自然就会联想到Handler，我们知道Handler是Android消息机制的上层接口，因此我们在开发过程中也只需要和Handler交互即可，很多人认为Handler的作用就是更新UI,这也确实没错，但除了更新UI，Handler其实还有很多其他用途，比如我们需要在子线程进行耗时的I/O操作，可能是读取某些文件或者去访问网络等，当耗时操作完成后我们可能需要在UI上做出相应的改变，但由于Android系统的限制，我们是不能在子线程更新UI控件的，否则就会报异常，这个时候Handler就可以派上用场了，我们可以通过Handler切换到主线程中执行UI更新操作。
下面是Handler一些常用方法：
voidhandleMessage（Messagemsg）:
处理消息的方法，该方法通常会被重写。
finalbooleanhasMessages（intwhat）:
检测消息队列中是否包含what属性为指定值的消息。
MessageobtainMessage（）:
获取消息的方法，此函数有多个重载方法。
sendEmptyMessage（intwhat）:
发送空消息。
finalbooleansendEmptyMessageDelayed（intwhat,longdelayMillis）:
指定多少毫秒后发送空消息。
finalbooleansendMessage（Messagemsg）:
立即发送消息。
finalbooleansendMessageDelayed（Messagemsg,longdelayMillis）:
指定多少毫秒后发送消息。
finalbooleanpost（Runnabler）:
执行runnable操作。
finalbooleanpostAtTime（Runnabler,longupTimeMillis）:
在指定时间执行runnable操作。
finalbooleanpostDelayed（Runnabler,longdelayMillis）:
指定多少毫秒后执行runnable操作。
介绍完方法后，我们就从一个简单的例子入手吧，然后一步步的分析：
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
publicclassMainActivityextendsAppCompatActivity{
publicstaticfinalintMSG_FINISH=0X001;
//创建一个Handler的匿名内部类
privateHandlerhandler=newHandler（）{
@Override
publicvoidhandleMessage（Messagemsg）{
switch（msg.what）{
caseMSG_FINISH:
LogUtils.e（"handler所在的线程id是-->"+Thread.currentThread（）.getName（））;
break;
}
}
};
@Override
protectedvoidonCreate（BundlesavedInstanceState）{
super.onCreate（savedInstanceState）;
setContentView（R.layout.activity_main）;
//启动耗时操作
consumeTimeThread（findViewById（R.id.tv））;
//handler.post（）
}
//启动一个耗时线程
publicvoidconsumeTimeThread（Viewview）{
newThread（）{
publicvoidrun（）{
try{
LogUtils.e（"耗时子线程的Name是--->"+Thread.currentThread（）.getName（））;
//在子线程运行
Thread.sleep（2000）;
//完成后，发送下载完成消息
handler.sendEmptyMessage（MSG_FINISH）;
}catch（InterruptedExceptione）{
e.printStackTrace（）;
}
}
}.start（）;
}
}
运行结果：
上面的例子其实就是Handler的基本使用，在主线中创建了一个Handler对象，然后通过在子线程中模拟一个耗时操作完成后通过sendEmptyMessage（int）方法发送一个消息通知主线程的Handler去执行相应的操作。
通过运行结果我们也可以知道Handler确实也是在主线程运行的。
那么问题来了，通过Handler发送的消息是怎么到达主线程的呢？
接下来我们就来掰掰其中的奥妙，前方高能，请集中注意力！
为了更好的理解Handler的工作原理，我们先来介绍与Handler一起工作的几个组件：
Message:
Handler接收和处理消息的对象。
Looper:
每个线程只能有一个Looper。
它的loop方法负责读取MessageQueue中的消息，读到消息后把消息发送给Handler进行处理。
MessageQueue：
消息队列，它采用先进先出的方式来管理Message。
程序创建Looper对象时，会在它的构造方法中创建MessageQueue对象。
Handler:
它的作用有两个—发送消息和处理消息，程序使用Handler发送消息，由Handler发送的消息必须被送到指定的MessageQueue;否则消息就没有在MessageQueue进行保存了。
而MessageQueue是由Looper负责管理的，也就是说，如果希望Handler正常工作的话，就必须在当前线程中有一个Looper对象。
我们先对上面的几个组件有大概的了解就好，后面我们都会详细分析，既然消息是从Handler发送出去，那么我们就先从Handler入手吧。
先来看看Handler的构造方法源码：
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
publicclassHandler{
/**
*未实现的空方法handleMessage（）
*/
publicvoidhandleMessage（Messagemsg）{
}
/**
*我们通常用于创建Handler的构造方法之一
*/
publicHandler（）{
this（null,false）;
}
//构造方法的内调用的this（null,false）的具体实现
publicHandler（Callbackcallback,booleanasync）{
//检查Handler是否是static的，如果不是的，那么有可能导致内存泄露
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我们先理解成一个消息队列的管理者，用来从消息队列中取消息的，后续会详细分析
mLooper=Looper.myLooper（）;
if（mLooper==null）{
//这个异常很熟悉吧，Handler是必须在有Looper的线程上执行，这个也就是为什么我在HandlerThread中初始化Handler
//而没有在Thread里面初始化，如果在Thread里面初始化需要先调用Looper.prepare方法
thrownewRuntimeException（
"Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare（）"）;
}
//将mLooper里面的消息队列复制到自身的mQueue,这也就意味着Handler和Looper是公用一个消息队列
mQueue=mLooper.mQueue;
//回调函数默认是Null
mCallback=null;
}
分析：
Handler的构造方法源码不是很多，也比较简单，但是我们从源码中也可以得知，在创建Handler时，Handler内部会去创建一个Looper对象，这个Looper对象是通过Looper.myLooper（）创建的（后续会分析这个方法），同时还会创建一个消息队列MessageQueue，而这个MessageQueue是从Looper中获取的，这也就意味着Handler和Looper共用一个消息队列，当然此时Handler,Looper以及MessageQueue已经捆绑到一起了。
上面还有一个情况要说明的，那就是:
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
if（mLooper==null）{
//这个异常很熟悉吧，Handler是必须在有Looper的线程上执行，这个也就是为什么我在HandlerThread中初始化Handler
//而没有在Thread里面初始化，如果在Thread里面初始化需要先调用Looper.prepare方法
thrownewRuntimeException（
"Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare（）"）;
}
这里先回去判断Looper是否为空，如果为null，那么就会报错，这个错误对我们来说应该比较熟悉吧，那为什么会报这个错误呢？
我们在前面说过Handler的作用有两个—发送消息和处理消息，我们在使用Handler发送消息，由Handler发送的消息必须被送到指定的MessageQueue;否则就无法进行消息循环。
而MessageQueue是由Looper负责管理的，也就是说，如果希望Handler正常工作的话，就必须在当前线程中有一个Looper对象。
那么又该如何保障当前线程中一定有Looper对象呢？
这里其实分两种情况：
（1）在主UI线程中，系统已经初始化好了一个Looper对象，因此我们可以直接创建Handler并使用即可。
（2）在子线程中，我们就必须自己手动去创建一个Looper对象，并且去启动它，才可以使用Handler进行消息发送与处理。
使用事例如下：
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
classchildThreadextendsThread{
publicHandlermHandler;
@Override
publicvoidrun（）{
//子线程中必须先创建Looper
Looper.prepare（）;
mHandler=newHandler（）{
@Override
publicvoidhandleMessage（Messagemsg）{
super.handleMessage（msg）;
//处理消息
}
};
//启动looper循环
Looper.loop（）;
}
}
分析完Handler的构造方法，我们接着看看通过Handler发送的消息到底是发送到哪里了？
我们先来看看Handler的几个主要方法源码：
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
//发送一个空消息的方法，实际上添加到MessagerQueue队列中
publicfinalbooleansendEmptyMessage（intwhat）{
returnsendEmptyMessageDelayed（what,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（ue==null）{
RuntimeExceptione=newRuntimeException（this
+"sendMessageAtTime（）calledwithnomQueue"）;
Log.w（"Looper",e.getMessage（）,e）;
returnfalse;
}
returnenqueueMessage（queue,msg,uptimeMillis）;
}
//最后调用此方法添加到消息队列中
privatebooleanenqueueMessage（MessageQueuequeue,Messagemsg,
longuptimeMillis）{
msg.target=this;//设置发送目标对象是Handler本身
if（mAsynchronous）{
msg.setAsynchronous（true）;
}
returnqueue.enqueueMessage（msg,uptimeMillis）;//添加到消息队列中
}
//在looper类中的loop（）方法内部调用的方法
publicvoiddispatchMessage（Messagemsg）{
if（msg.callback!
=null）{
handleCallback（msg）;
}else{
if（mCallback!
=null）{
if（mCallback.handleMessage（msg））{
return;
}
}
handleMessage（msg）;
}
}
分析：
通过源码我们可以知道，当我们调用sendEmptyMessage（int）发送消息后。
最终Handler内部会去调用enqueueMessage（MessageQueuequeue,Messagemsg）方法把发送的消息添加到消息队列MessageQueue中，同时还有设置msg.target=this此时就把当前handler对象绑定到msg.target中了，这样就完成了Handler向消息队列存放消息的过程。
这个还有一个要注意的方法dispatchMessage（Message）,这个方法最终会在looper中被调用（这里我们先知道这点就行，后续还会分析）。
话说我们一直在说MessageQueue消息队列，但这个消息队列到底是什么啊？
其实在Android中的消息队列指的也是MessageQueue，MessageQueue主要包含了两种操作，插入和读取，而读取操作本身也会伴随着删除操作，插入和读取对应的分别是enqueueMessage和next，其中enqueueMessage是向消息队列中插入一条消息，而next的作用则是从消息队列中取出一条消息并将其从队列中删除。
虽然我们一直称其为消息队列但是它的内部实现并不是队列，而是通过一个单链表的数据结构来维护消息列表的，因为我们知道单链表在插入和删除上比较有优势。
至内MessageQueue的内部实现，这个属于数据结构的范畴，我们就不过多讨论了，还是回到原来的主题上来，到这里我们都知道Handler发送的消息最终会添加到MessageQueue中，但到达MessageQueue后消息又是如何处理的呢？
还记得我们前面说过MessageQueue是由Looper负责管理的吧，现在我们就来看看Looper到底是如何管理MessageQueue的？
[java]viewplaincopyprint?
在CODE上查看代码片派生到我的代码片
publicfinalclassLooper{
//sThreadLocal.get（）willreturnnullunlessyou'vecalledprepare（）.
//存放线程的容器类,为确保获取的线程和原来的一样
staticfinalThreadLocalsThreadLocal=newThreadLocal（）;
privatestaticLoopersMainLooper;//guardedbyLooper.class
//消息队列
finalMessageQueuemQueue;
finalThreadmThread;
//perpare（）方法，用来初始化一个Looper对象
publicstaticvoidprepare（）{
prepare（true）;
}
privatestaticvoidprepare（booleanquitAllowed）{
if（sThreadLocal.get（）!
=null）{
thrownewRuntimeException（"OnlyoneLoopermaybecreatedperthread"）;
}
sThreadLocal.set（newLooper（quitAllowed））;
}
//handler调用的获取Looper对象的方法。
实际是在ThreadLocal中获取。
publicstaticLoopermyLooper（）{
returnsThreadLocal.get（）;
}
//Looper类的构造方法，可以发现创建Looper的同时也创建了消息队列MessageQueue对象
privateLooper（booleanquitAllowed）{
mQueue=newMessageQueue（quitAllowed）;
mRun=true;
mThread=Thread.currentThread（）;
}
//这个方法是给系统调用的，UI线程通过调用这个线程，从而保证UI线程里有一个Looper
//需要注意：
如果一个线程是UI线程，那么myLooper和getMainLooper是同一个Looper
publicstaticfinalvoidprepareMainLooper（）{
prepare（）;
setMainLooper（myLooper（））;
if（Process.supportsProcesses（））{
myLooper（）.mQueue.mQuitAllowed=false;
}
}
//获得UI线程的Looper,通常我们想Hanlder的handleMessage在UI线程执行时通常会newHandler（getMainLooper（））;
publicsynchronizedstaticfinalLoopergetMainLooper（）{
returnmMainLooper;
}
//looper中最重要的方法loop（），该方法是个死循环，会不断去消息队列MessageQueue中获取消息，然后调dispatchMessage（msg）方法去执行
publicticvoidloop（）{
finalLooperme=myLooper（）;
if（me==null）{
thrownewRuntimeException（"NoLooper;Looper.prepare（）wasn'tcalledonthisthread."）;
}
finalMessageQueuequeue=me.mQueue;
//死循环
for（;;）{
Messagemsg=queue.next（）;//mightblock
if（msg==null）{
//Nomessageindicatesthatthemessagequeueisquitting.
return;
}
//这里其实就是调用handler中的方法，而在Handler的源码中也可以知道dispatchMessage（msg）内部调用的就是handlerMessage（）方法
msg.target.dispatchMessage（msg）;
msg.recycle（）;
}
}
分析：
代码不算多，我们拆分开慢慢说，在Looper源码中我们可以得知其内部是通过一个ThreadLocal的容器来存放Looper的对象本身的，这样就可以确保每个线程获取到的looper都是唯一的
升级会员 