前言
Android的消息机制用于同进程的线程间通信，它是由MessageQueue，Message，Looper，Handler共同组成，Android中大量的交互都是通过消息机制，比如四大组件启动过程与服务的交互、View的绘制、更新等都离不开消息机制，所以Android在某种意义上也可以说成是一个以消息驱动的系统，在Android中消息机制的运作分为java层和native层，它们之间的运作机制不一样，本文讲解的是java层的消息机制，如果你想了解native层的消息机制，可以阅读：
但其实java层的消息机制的核心功能都交给了native层的消息机制来完成，但作为应用开发，首先要掌握java层的消息机制。
本文源码基于Android8.0，源码相关位置:
frameworks/base/core/java/android/os/*.java (*代表MessageQueue、Handler、Looper、Message)
消息机制概述
Android应用的每个事件都会转化为一个系统消息即Message，消息中包含了事件的相关信息和消息的处理人即Handler，消息要通过Handler发送，最终被投递到一个消息队列中即MessageQueue，它维护了一个待处理的消息列表，然后通过Looper开启了一个消息循环不断地从这个队列中取出消息，当从消息队列取出一个消息后，Looper根据消息的处理人（target）将此消息分发给相应的Handle处理，整个过程如下图所示。
它们的工作原理就像工厂的生产线，Looper是发动机，MessageQueue是传送带，Handler是工人，Message则是待处理的产品。
java层消息机制架构图
handler2.png
- Looper --- 是每个线程的MessageQueue管家，里面有一个MessageQueue消息队列，负责把消息从MessageQueue中取出并把消息传递到Handler中去，每个线程只有一个Looper；
- MessageQueue --- 消息队列，有一组待处理的Message，主要用于存放所有通过Handler发送的消息，每个线程只有一个MessageQueue；
- Message --- 是线程之间传递的消息，里面有一个用于处理消息的Handler；
- Handler --- 主要用于发送和处理消息，里面有Looper和MessageQueue。
简单使用
在开发中，我们在子线程中执行完操作后通常需要更新UI，但我们都知道不能在子线程中更新UI，此时我们就要通过Handler将一个消息post到UI线程中，然后再在Handler中的handleMessage方法中进行处理，如果我们不传递UI线程所属的Looper去创建Handler，那么该Handler必须在主线程中创建，如下：
//在主线程中创建Handler
Handler mHandler = new Handler（）{
@Override
public void handleMessage(Message msg){
//更新UI
}
}
//在子线程中进行耗时操作
new Thread（）{
public void run(){
mHandler.sendEmptyMessage(0);
}
}
以上就是我们平时使用Handler的常规用法了。
接下来我们以应用主线程(又叫做UI线程)的消息机制运作为例讲解Android消息机制的原理。
源码分析
1、 Looper的创建
我们知道Android应用程序的入口实际上是ActivityThread.main方法，而应用的消息循环也是在这个方法中创建，具体源码如下：
//ActivityThread.java
public static void main(String[] args) {
//...
//1、创建消息循环Looper
Looper.prepareMainLooper();
//...
//2、执行消息循环
Looper.loop();
}
我们关注注释1，ActivityThread调用了Looper的prepareMainLooper方法来创建Looper实例，Looper的prepareMainLooper方法如下：
//Looper.java
public static void prepareMainLooper() {
//1、创建不允许退出的Looper
prepare(false);
synchronized (Looper.class) {//保证只有一个线程执行
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
//2、将刚刚创建的Looper实例赋值给sMainLooper
//sMainLooper字段是Looper类中专门为UI线程保留的，只要某个线程调用了prepareMainLooper方法，把它创建的Looper实例赋值给sMainLooper，它就可以成为UI线程，prepareMainLooper方法只允许执行一次
sMainLooper = myLooper();
}
}
private static void prepare(boolean quitAllowed){//quitAllowed表示是否允许Looper运行时退出
//Looper.prepare()只能执行一次
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//把Looper保存到TLS中
sThreadLocal.set(new Looper(quitAllowed));
}
public static @Nullable Looper myLooper() {
//获取当前线程TLS区域的Looper
return sThreadLocal.get();
}
private static Looper sMainLooper; // guarded by Looper.class
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
线程在调用prepareMainLooper方法后，就代表它成为了一个UI线程，可以看到prepareMainLooper方法中是调用Looper的prepare方法来创建Looper实例，当要获取创建的Looper实例时，是通过Looper的myLooper方法来获取的，在调用prepare方法时，会把创建的Looper实例set到ThreadLocal中，当获取时也会从ThreadLocal中通过get方法获取，那么ThreadLocal是什么？这里简单介绍一下ThreadLocal：
ThreadLocal：线程本地存储区（Thread Local Storage，简称为TLS），每 个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。
它的常用操作方法有：
ThreadLocal.set(T value)：将value存储到当前线程的TLS区域。
ThreadLocal.get()：获取当前线程TLS区域的数据关于ThreadLocal更多信息可以查看ThreadLocal原理解析
ThreadLocal的get()和set()方法操作的类型都是泛型，我们从ThreadLocal在Looper中的定义可以看出，sThreadLocal的get()和set()操作的类型都是Looper类型, 所以，由于ThreadLocal的作用，每个线程只能保存一个Looper，不同线程的Looper是不相同的，这样，通过调用Looper.prepare(false)方法，UI线程中就保存了它对应的、唯一的Looper实例，当在UI线程调用Looper.myLooper方法时它就会返回UI线程关联的Looper实例，当然，如果你在子线程中想要获得UI线程关联的Looper实例，就需要调用getMainLooper方法，该方法如下：
public static Looper getMainLooper() {
synchronized (Looper.class) {
//返回UI线程的Looper实例
return sMainLooper;
}
}
以上就是UI线程的Looper的创建过程，执行ActivityThread.main后，应用程序就启动了，UI的消息循环也在Looper.loop方法中启动，此后Looper会一直从消息队列中取出消息，用户或系统通过Handler不断往消息队列中添加消息，这些消息不断的被取出，处理，回收，使得应用运转起来。
我们在平时开发时，一般是使用不带参数的prepare()方法来创建子线程对应的Looper实例，如下：
//我们平时使用的prepare方法
public static void prepare() {
//quitAllowed = true
prepare(true);
}
和UI线程的区别是，UI线程的Looper是不允许推出的，而我们的Looper一般是允许退出的。
2、MessageQueue的创建
我们在上面知道，调用Looper的prepare方法就会创建Looper实例，同时会把Looper实例通过ThreadLocal保存到线程中，在创建Looper时还会同时在构造中创建MessageQueue实例，如下：
//Looper.java
final MessageQueue mQueue;
//Looper唯一的构造函数
private Looper(boolean quitAllowed) {
//可以看到MessageQueue是在Looper中创建的
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Looper只有这一个构造函数，并且它是私有的，所以我们只能通过Looper的prepare方法创建Looper实例，由于ThreadLocal，每个线程最多只能对应一个Looper实例，而每个Looper内部只有一个MessageQueue实例，推出：每个线程最多对应一个MessageQueue实例。
我们看一下MessageQueue的构造，如下：
//MessageQueue.java
private long mPtr; // used by native code
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
//通过native方法初始化消息队列，其中mPtr是供native代码使用
mPtr = nativeInit();
}
MessageQueue的构造中会通过native方法在native层创建一个属于native层的消息队列NativeMessageQueue，然后把NativeMessageQueue的地址返回给java层保存在mPtr中，java层和native层之间的通信就通过这个mPtr指针。
MessageQueue是消息机制的核心类，它是java层和native层的连接纽带，它里面有大量的native方法，Android有俩套消息机制（java层和native层，实现不一样），但本文只讲解java层的消息机制，不会涉及到native层.
关于native层的查看Android消息机制（native层）
我们通过Looper的myQueue方法就能获取到它关联的MessageQueue实例，如下：
//Looper.java
public static @NonNull MessageQueue myQueue() {
//先通过TLS获取Looper实例，再从对应的Looper中获取MessageQueue实例
return myLooper().mQueue;
}
3、消息循环的运行
在ActivityThread的mian方法在创建Looper后，通过Looper.loop方法就启动了消息循环，这个函数会不断的从MessageQueue中取出消息、处理消息，我们点进此方法看一下它的源码：
//Looper.java
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//从Looper中取出MessageQueue
final MessageQueue queue = me.mQueue;
//...
for (;;) {
//1、从MessageQueue中取出消息，没有消息时会阻塞等待
Message msg = queue.next();
//next()返回了null，表示MessageQueue正在退出，即调用了Looper的quit或quitSafely方法
if (msg == null) {
return;
}
//...
//2、分发消息
msg.target.dispatchMessage(msg);
//...
//3、回收消息
msg.recycleUnchecked();
}
}
loop()中是一个死循环，我们关注注释1，loop()会调用MessageQueue的next()来获取最新的消息，当没有消息时，next()会一直阻塞在那里，这也导致loop()阻塞，唯一跳出循环的条件是next()返回null，这时代表Looper的quit()或quitSafely()被调用，从而调用MessageQueue的quit()来通知消息队列退出，如下：
//Looper.java
public void quit() {
mQueue.quit(false);
}
//quitSafely和quit方法的区别是，quitSafely方法会等MessageQueue中所有的消息处理完后才退出，而quit会直接退出
public void quitSafely() {
mQueue.quit(true);
}
所以MessageQueue的next()是最关键的函数，我们来看看next函数的关键代码：
//MessageQueue.java
Message next() {
//mPtr是在构造中被赋值，是指向native层的MessageQueue
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1;
int nextPollTimeoutMillis = 0;
//一个死循环，里面分为两部分，1、处理java层消息；2、如果没有消息处理，执行IdleHandler
for(;;){
//...
//Part1：获取java层的消息处理
//nativePollOnce方法用于处理native层消息，是一个阻塞操作
//它在这两种情况下返回：1、等待nextPollTimeoutMillis时长后；2、MessageQueue被唤醒
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
//mMessages是java层的消息队列，这里表示取出消息队列的第一个消息
Message msg = mMessages;
if (msg != null && msg.target == null) {//遇到同步屏障（target为null的消息）
//在do-while中找到异步消息，优先处理异步消息
//异步消息的isAsynchronous方法返回true
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {//有消息
if (now < msg.when) { //消息还没到触发时间
//设置下一次轮询的超时时长（等待时长）
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {//now == msg.when, 消息到达触发时间
mBlocked = false;
//从mMessages的头部获取一条消息并返回
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
//设置消息的使用状态，即flags |= FLAG_IN_US
msg.markInUse();
//返回这个消息
return msg;
}
} else {//msg == null，没有消息
//设置nextPollTimeoutMillis为-1，准备进入阻塞，等待MessageQueue被唤醒
nextPollTimeoutMillis = -1;
}
//调用了quit方法
if (mQuitting) {
dispose();
return null;
}
//当处于以下2种情况时，就会执行到Part2：
//1、mMessages == null，java层没有消息处理
//2、now < msg.when，有消息处理，但是还没有到消息的执行时间
//1、2两种情况都表明线程的消息队列处于空闲状态，处于空闲状态，就会执行IdleHandler
//Part2：没有消息处理，执行IdleHandler
//mIdleHandlers表示IdleHandler列表
//pendingIdleHandlerCount表示需要执行的IdleHandler的数量
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
//没有IdleHandler需要处理，可直接进入阻塞
mBlocked = true;
continue;
}
//有IdleHandler需要处理
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
//把mIdleHandlers列表转成mPendingIdleHandlers数组
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
//遍历mPendingIdleHandlers数组
for (int i = 0; i < pendingIdleHandlerCount; i++) {
//取出IdleHandler
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
//执行IdleHandler的queueIdle方法，通过返回值由自己决定是否保持存活状态
keep = idler.queueIdle();
}
//...省略异常处理
if (!keep) {
// 不需要存活，移除
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
//重置pendingIdleHandlerCount和nextPollTimeoutMillis为0
pendingIdleHandlerCount = 0;
//nextPollTimeoutMillis为0，表示下一次循环会马上从Messages中取出一个Message判断是否到达执行时间
//因为IdleHandler在处理事件的时间里，有可能有新的消息发送来过来，需要重新检查
nextPollTimeoutMillis = 0;
}
}
MessageQueue的next方法有点长，但是它里面的逻辑是很好理解的，它主要是通过一个死循环不断的返回Message给Looper处理，next方法可以分为两部分阅读：
1、获取java层的消息处理：
我们看Part1，先执行nativePollOnce方法，它是一个阻塞操作，其中nextPollTimeoutMillis代表下一次等待的超时时长，当nextPollTimeoutMillis = 0时或到达nextPollTimeoutMillis时，它会立即返回；当nextPollTimeoutMillis = -1时，表示MessageQueue中没有消息，会一直等待下去，直到Hanlder往消息队列投递消息，执行nativeWake方法后，MessageQueue被唤醒，nativePollOnce就会返回，但它此时并不是立即返回，它会先处理完native层的消息后，再返回，然后获取java层的消息处理；
接着next方法就会从mMessages链表的表头中获取一个消息，首先判断它是否是同步屏障，同步屏障就是target为null的Message，如果遇到同步屏障，MessageQueue就会优先获取异步消息处理，异步消息就是优先级比同步消息高的消息，我们平时发送的就是同步消息，通过Message的setAsynchronous(true)可以把同步消息变成异步消息，不管是同步还是异步，都是Message，获取到Message后；
接着判断Message是否到达它的执行时间(if(now == msg.when))，如果到达了执行时间，next方法就会返回这条消息给Looper处理，并将其从单链表中删除；如果还没有到达执行时间，就设置nextPollTimeoutMillis为下一次等待超时时长，等待下次再次取出判断，可以发现虽然MessageQueue叫消息队列，但它却不是用队列实现的，而是用链表实现的。
通过MessageQueue的postSyncBarrier方法可以添加一个同步屏障，通过removeSyncBarrier方法可以移除相应的同步屏障，在Android，Choreographer机制中就使用到了异步消息，在View树绘制之前，会先往UI线程的MessageQueue添加一个同步屏障，拦截同步消息，然后发送一个异步消息，等待VSYN信号到来，触发View树绘制，这样就可以让绘制任务优先执行。
2、没有消息处理，遍历IdleHandler列表，执行IdleHandler的queueIdle方法：
IdleHandler是什么？IdleHandler是一个接口，它里面只有一个queueIdle方法，Idle是空闲的意思，在MessageQueue空闲的时候会执行IdleHandler的queueIdle方法，我们可以通过MessageQueue的addIdleHandler方法添加我们自定义的IdleHandler到mIdleHandlers列表中，如下：
//MessageQueue.java
private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
public void addIdleHandler(@NonNull IdleHandler handler) {
//...
mIdleHandlers.add(handler);
}
MessageQueue空闲，就代表它处于以下两种情况：
(1) mMessages == null，消息队列中没有消息处理；
(2) now < msg.when，有消息处理，但是还没有到消息的执行时间.
以上两种情况之一都会触发next方法遍历IdleHandler列表，执行IdleHandler的queueIdle方法的操作。
在Android中，我们平时所说的线程空闲其实就是指线程的MessageQueue空闲，这时就可以执行我们添加的IdleHandler，例如在LeakCanary中，它通过添加IdleHandler，在UI线程空闲时执行内存泄漏的判断逻辑.
4、消息的发送
到这里UI线程已经启动了消息循环，那么消息从何而来？消息是由系统产生，然后通过Hanlder发送到MessageQueue中，Handler就是用来处理和发送消息的，应用程序的Handler在ActivityThread中被创建，如下：
//ActivityThread.java
final H mH = new H();
//H定义如下，继承Hanldler
//里面定义了大量的字段，跟Activity的启动，Application的绑定等有关
class H extends Handler {
public static final int BIND_APPLICATION = 110;
public static final int EXIT_APPLICATION = 111;
public static final int CREATE_SERVICE = 114;
//....
public void handleMessage(Message msg) {
switch (msg.what) {
case BIND_APPLICATION:
//...
case EXIT_APPLICATION:
//...
case CREATE_SERVICE:
//...
//...
}
//...
}
mH就是应用程序内部使用的Handler，我们外部是不可使用的，应用程序通过Handler往MessageQueue中投递消息，并通过Handler的handlerMessage方法处理消息，而我们在外部也可以使用自己创建的Handler往UI线程的MessageQueue投递消息。
既然Handle可以往MessageQueue中投递消息，这说明Handler要和相应的MessageQueue关联，我们看Handler的构造函数，Handler有两种构造函数：
一种是指定Callback的构造函数，Callback默认为null，如下：
//Handler.java
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(boolean async) {
this(null, async);
}
public Handler(Callback callback, boolean async) {
//...
//先通过TLS获取Looper实例，与Looper关联
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
//通过Looper获取MessageQueue，与MessageQueue关联
mQueue = mLooper.mQueue;
//Callback的作用在消息的分发中会讲到
mCallback = callback;
mAsynchronous = async;
}
在构造中如果通过Looper.myLooper方法获取不到Looper，就会抛出“Can't create handler inside threadxx that has not called Looper.prepare()”异常，所以如果我们在子线程中使用Handler的默认构造，没有先调用Looper.prepare方法就创建Handler的话，就会抛出上述异常，但是在UI线程中就不会，因为应用程序启动时就已经调用了Looper的prepareMainLooper方法，在该方法里面已经调用了prepare(false)方法创建了UI线程的Looper实例，无需我们再次调用Looper.prepare方法。
另外一种是指定Looper的构造函数(如果不指定，Looper默认从当前线程的TLS区域获取)，如下：
//Handler.java
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
public Handler(Looper looper, Callback callback, boolean async) {
//与Looper关联
mLooper = looper;
//通过Looper获取MessageQueue，与MessageQueue关联
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
不管哪一种构造函数，可以看到，在Handler的最终构造中都会和对应线程的Looper、MessageQueue关联，所以就算Hander在子线程创建，我们也可以通过: Handler = new Handler(Looper.getMainLooper)；把Handler关联上UI线程的Looper，并通过Looper关联上UI线程的MessageQueue，这样，就能把Handler运行在UI线程中。
消息的发送可以通过handler的一系列post方法和一系列的send方法，一系列post方法最终通过一系列send方法来实现，一系列send方法最终通过enqueueMessage方法来发送消息，如下：
handler3.png
可以发现Handler所有发送消息的方法，最终都是调用Handler的enqueueMessag方法，该方法源码如下：
//Handler.java
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
在该方法中，首先把Message的target字段设置为当前发送消息的Handler, 然后设置Message是否是异步消息，最后把所有逻辑交给MessageQueue的enqueueMessage方法，该方法的相应源码如下：
//MessageQueue.java
boolean enqueueMessage(Message msg, long when) {
//...
synchronized (this) {
//正在退出时，回收msg，加入到消息池
if (mQuitting) {
//...
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
boolean needWake;
//取mMessages链表头部的消息
Message p = mMessages;
//满足以下2种情况之一就把msg插入到链表头部：
//1、如果p为null，则代表mMessages没有消息
//2、如果when == 0 或 when < p.when, 则代表msg的触发时间是链表中最早的
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;//如果处于阻塞状态，需要唤醒
} else {//3、如果p != null且msg并不是最早触发的，就在链表中找一个位置把msg插进去
//如果处于阻塞状态，并且链表头部是一个同步屏障，并且插入消息是最早的异步消息，需要唤醒
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
//下面是一个链表的插入操作, 将消息按时间顺序插入到mMessages中
for (;;) {
prev = p;
p = p.next；
if (p == null || when < p.when) {
break;
}
//如果在找到插入位置之前，发现了异步消息的存在，不需要唤醒
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
//nativeWake方法会唤醒当前线程的MessageQueue
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
MessageQueue的enqueueMessage方法主要是一个链表的插入操作，返回true就代表插入成功，返回false就代表插入失败，它主要分为以下3种情况：
1、插入链表头部：
mMessages是按照Message触发时间的先后顺序排列的，越早触发的排得越前，头部的消息是将要最早触发的消息，当有消息需要加入mMessages时，如果mMessages为空或这个消息是最早触发的，就会直接插入链表头部；
2、插入链表的中间位置：
如果消息链表不为空并且插入的消息不是最早触发的，就会从链表头部开始遍历，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序，这一个过程可以理解为插入排序；
3、判断是否调用nativeWake方法
最后，根据needWake是否为true，来决定是否调用nativeWake方法唤醒当前线程的MessageQueue，needWake默认为false，即不需要唤醒，needWake为true就代表此时处于以下2种情况：
（1）如果插入消息在链表头部并且mBlocked == true，表示此时nativePollOnce方法进入阻塞状态，等待被唤醒返回；
（2）如果插入消息在链表中间，消息链表的头部是一个同步屏障，同时插入的消息是链表中最早的异步消息，需要唤醒，即时处理异步消息。
5、消息的分发
在消息循环的运行中，如果loop方法中MessageQueue的next方法返回了Message，那么就会执行到这一句：msg.target.dispatchMessage(msg)；Looper会把这条消息交给该Message的target（Handler对象）来处理, 实际上是转了一圈，Handler把消息发送给MessageQueue，Looper又把这个消息给Handler处理，下面来看消息分发逻辑，dispatchMessage()源码如下：
//Handler.java
public void dispatchMessage(Message msg) {
//1、检查msg的callback是否为空
if (msg.callback != null) {
handleCallback(msg);
} else {
//2、Handler的mCallback是否为空
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//3、我们平常处理消息的方法，该方法默认为空，Handler子类通过覆写该方法来完成具体的逻辑。
handleMessage(msg);
}
}
里面代码量很少，分为3步：
1、检查msg.callback是否为空，不为空则执行" handleCallback(msg)", 源码如下:
//Handler.java
private static void handleCallback(Message message) {
message.callback.run();
}
msg.callback其实是一个Runnable对象，当我们通过Handler来post一个Runnable消息时，它就不为空，如下：
//Handler.java
public final boolean post(Runnable r){
return sendMessageDelayed(getPostMessage(r), 0);
}
//把Runnable对象包装成Message对象
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看到，在post(Runnable r)中，会把Runnable包装成Message对象，并把Runnable设置给Message的callback字段，然后发送此消息。
2、如果msg.callback为空，检查mCallback是否为空，mCallback是一个Callback接口，定义如下：
//Handler.java
public interface Callback {
public boolean handleMessage(Message msg);
}
当我们这样：Handler handler = new Handler(callback) 来创建Handler时, mCallback就不为空，它的意义是当我们不想派生Handler的子类重写handleMessage()来处理消息时，就可以通过Callback来实现。
3、如果mCallback为空，最后调用Handler的handleMessage方法来处理消息，这就是我们平时熟悉的处理消息的方法。
从1、2、3可以看出，在Handler中，处理消息的回调的优先级为：Message的Callback > Handler的Callback > Handler的handleMessage方法。
6、消息的回收复用
1、消息的复用
前面多次提到了Message，当我们通过Handler的obtainMessage()或Message的obtain()获取一个Message对象时，系统并不是每次都new一个出来，而是先从消息池中（sPool）尝试获取一个Message。Handler的obtainMessage()最终是调用了Message的obtain()，Message的obtain方法如下:
//Message.java
public static Message obtain() {
synchronized (sPoolSync) {
//从sPool头部取出一个Message对象返回，并把消息从链表断开（即把sPool指向下一个Message）
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0;//清除in-use flag
sPoolSize--;//消息池的大小进行减1操作
return m;
}
}
//消息池中没有Message，直接new一个返回
return new Message();
sPool的数据类型为Message，通过next成员变量，维护一个消息池，消息池的默认大小为50。定义如下:
public final class Message implements Parcelable {
public static final Object sPoolSync = new Object();//用于在获取Message对象时进行同步锁
private static int sPoolSize = 0;//池的大小
private static final int MAX_POOL_SIZE = 50;//池的可用大小
private static Message sPool;
Message next;
//...
}
虽然叫消息池，其实是通过链表实现的，每个Message都有一个同类型的next字段，这个next就是指向下一个可用的Message，最后一个可用的Message的next为空，这样所有可用的Message对象就通过next串成一个Message池，sPool指向池中的第一个Message，复用消息其实是从链表的头部获取一个Message返回。
2、消息的回收
我们发现在obtain方法中新创建Message对象时，并不会直接把它放到池中再返回，那么Message对象是什么时候被放进消息池中的呢？是在回收Message时把它放入池中，Message中也有类似Bitmap那样的recycler函数，如下：
//Message.java
public void recycle() {
//判断消息是否正在使用
if (isInUse()) {
if (gCheckRecycle) {//Android 5.0以后的版本默认为true,之前的版本默认为false.
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}
//对于不再使用的消息，加入到消息池
void recycleUnchecked() {
//将消息标示位置为IN_USE，并清空消息所有的参数
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
//当消息池没有满时，将Message对象加入消息池（即把Message插入链表头部）
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;//消息池的可用大小进行加1操作
}
}
}
recycler函数先判断该Message是否还在使用，如果还在使用，就会抛异常，否则就调用recyclerUnchecked函数根据MAX_POOL_SIZE判断是否把该消息回收，回收前还要先清空该消息的各个字段，回收消息就是把自身插入到链表的表头。
通过消息的复用回收，减少Message对象不断创建与销毁的过程，提升了效率。
7、小结
1、创建Looper时，只能通过Looper的prepare方法创建，在创建Looper时会在内部创建一个MessageQueue，并把Looper保存在线程的TLS区域中，一个线程只能对应一个Looper，一个Looper只能对应一个MessageQueue；
2、在创建MessageQueue时，MessageQueue与NativeMessageQueue建立连接，NativeMessageQueue存储地址存于MessageQueue的mPtr字段中，java层和native通过mPtr字段进行通信（native端通过Linux的epoll机制建立起消息机制）;
3、由于ThreadLocal的作用，Looper属于某个线程，而MessageQueue存储在Looper中，所以MessageQueue则通过Looper与特定的线程关联上，而Handler在构造中又与Looper和MessageQueue相关联，当我们通过Handler发送消息时，消息就会被插入到Handler关联的MessageQueue中，而Looper会不断的轮询消息，从MessageQueue中取出消息给相应的Handler处理，所以最终通过Handler发送的消息就会被执行到Looper所在线程上，这就是Handler线程切换的原理，无论发送消息的Handler对象处于什么线程，最终处理消息的都是Looper所在线程；
4、Looper从MessageQueue中取出消息后，会交给消息的target(Handler)处理，在Handler中，处理消息的回调的优先级为：Message的Callback > Handler的Callback > Handler的handleMessage方法；
5、因为应用程序启动时在ActivityThread.main方法中的Looper.prepareMainLooper()中已经调用了Looper.prepare(false),所以在主线程中创建Handler无需我们手动调用Looper.prepare()，而在子线程中，如果我们不传递UI线程所属的Looper去创建Handler，那么就需要调用Looper.prepare()后再创建Handle来传递消息，因为Handler要和某个线程中的MessageQueue和Looper关联，只有调用Looper.prepare方法，Looper和MessageQueue才属于某个线程；
6、消息池是一个单链表，复用Message时，从头出取出，如果取不到，则新建返回，回收Message时，也从头插入。
结语
本文从Android应用UI线程消息循环的创建，消息循环的启动，Handler与Looper、MessageQueue的关联，消息的发送与分发，还有消息的复用这几个角度来讲解了Message，Handler，MessageQueue，Looper之间是如何配合工作，在你了解java层的消息机制是如何运作后，希望大家去了解一下native的消息机制，例如要想知道为什么loop方法是死循环但却不会消耗性能，这些只有native层的消息机制才能给你答案.
除此之外，我们还知道了MessageQueue的IdleHandler的作用，它会在线程空闲时工作，还有异步消息的处理，它的优先级高于同步消息，会被优先处理，还有它们的应用场景，一般我们是在子线程切换到UI线程时使用Handler机制，但其实我们也可以在子线程使用Handler机制，可以参考Android中的HandlerThread，它的底层就是Handler+Thread.
以上就是本文的全部内容，希望大家有所收获。
参考资料：
网友评论