Android从某种意义上看是一个以消息驱动的系统，内部含有大量以消息驱动的当时进行的交互，比如四大组件的启动、又比如常见的将子线程的任务切换到Handler所在的主线程中执行等等，它属于进程内部的一种通信方式。这篇文章就对android的消息机制做一个简单的梳理。
一、关键类简介
消息机制主要涉及Looper/MessageQueue/Message/Handler/ThreadLocal这几个类。
Looper：消息泵。一个死循环，有消息来就处理，没有消息就等待。一个线程最多只能有一个Looper对象，一个Looper对应管理此线程的MessageQueue，两者一一对应。
MessageQueue：消息队列。内部存储了一组消息，以队列的形式对外提供向消息池投递消息(MessageQueue.enqueueMessage)和取走消息(MessageQueue.next)的工作，内部采用单链表的数据结构来存储消息列表。
Message：消息。分为硬件产生的消息(如按钮、触摸)和软件生成的消息。
Handler：消息处理者。主要向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；
ThreadLocal：一个线程内部的数据存储类。保证线程内部数据在各线程间相互独立。
先看看消息机制整体流程：
二、源码分析
2.1 Looper
Looper的字面意思是“循环者”，它被设计用来使一个普通线程变成Looper线程。所谓Looper线程就是循环工作的线程。
主要方法有两个：
1) prepare() : 使Thread变成looper线程，具备循环的能力
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
看这个方法，就是创建一个Looper放到当前Thread对应的sThreadLocal里去。ThreadLocal前面讲过，它主要作用就是让线程间存储数据相互独立，显然这里它保证的是线程对应的 Looper一一对应且相互独立。
我们再看看Looper的构造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Looper内包含了一个初始化的MessageQueue，也关联了当前的Thread。
那么总结下关系就是：一个Thread对应的ThreadLocal保持了对应的Looper，而Looper关联了MessageQueue与当前Thread。
2) loop():
public static void loop() {
final Looper me = myLooper();//获取当前线程本地存储区存储的 Looper对象
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;//获取Looper对象对应的消息队列
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {//looper主循环方法，是个死循环
Message msg = queue.next(); // 取走消息池的消息去处理，可能会阻塞
...
try {
msg.target.dispatchMessage(msg);//分发Message
}
...
msg.recycleUnchecked();//将消息放入消息池
}
}
loop()进入循环模式，不断重复下面的操作，直到没有消息时退出循环
- 读取MessageQueue的下一条Message； Message msg = queue.next();
- 把Message分发给相应的target；msg.target.dispatchMessage(msg)；
- 再把分发后的Message回收到消息池，以便重复利用。msg.recycleUnchecked()；
总结： Looper主要就是让线程具备消息泵的循环能力，仅此而已。
2.2MessageQueue
MessageQueue看名字像是一个队列, 其实是以链表的形式保存message。其次，MessageQueue是消息机制的Java层和C++层的连接纽带，大部分核心方法都交给native层来处理。
例如消息的阻塞处理：
private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
在此我先只关心几个方法：
1) next():
之前在Looper 的loop()死循环中见过此方法，作用是取出消息进行处理，而且有可能会阻塞。
下面我们来看看源码，方法稍微有点长：
Message next() {
final long ptr = mPtr;
if (ptr == 0) {//当消息循环已经退出，直接返回
return null;
}
int pendingIdleHandlerCount = -1; // 循环迭代的首次为-1
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//阻塞操作，当等待nextPollTimeoutMillis时长，或者消息队列被唤醒，都会返回
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
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 {
//获取一条消息
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
//没有消息，当nextPollTimeoutMillis = -1时，表示消息队列中无消息，会一直等待下去
nextPollTimeoutMillis = -1;
}
// 消息正在退出,返回null
if (mQuitting) {
dispose();
return null;
}
//当消息队列为空，或者是消息队列的第一个消息时
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
//没有idle handlers 需要运行，则循环并等待。
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
//只有第一次循环时，会运行idle handlers，执行完成后，重置pendingIdleHandlerCount为0.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; //去掉handler的引用
boolean keep = false;
try {
keep = idler.queueIdle();//idle时执行的方法
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
//重置idle handler个数为0，以保证不会再次重复运行
pendingIdleHandlerCount = 0;
//当调用一个空闲handler时，一个新message能够被分发，因此无需等待可以直接查询pending message.
nextPollTimeoutMillis = 0;
}
}
nativePollOnce是阻塞操作，其中nextPollTimeoutMillis代表下一个消息到来前，还需要等待的时长；当nextPollTimeoutMillis = -1时，表示消息队列中无消息，会一直等待下去。
当处于空闲时，往往会执行IdleHandler中的方法。当nativePollOnce()返回后，next()从mMessages中提取一个消息。
nativePollOnce()在native做了大量的工作。
2) enqueueMessage:
该方法是添加一条消息到消息队列，下面具体来看看实现：
boolean enqueueMessage(Message msg, long when) {
// 每一个普通Message必须有一个target
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
if (msg.isInUse()) {
throw new IllegalStateException(msg + " This message is already in use.");
}
synchronized (this) {
if (mQuitting) {//正在退出时，回收msg，加入到消息池
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
//p==null代表MessageQueue没消息，或者msg的触发时间是队列中最早的，则进入该分支
msg.next = p;
mMessages = msg;
needWake = mBlocked;//当阻塞时需要唤醒
} else {
//将消息按时间顺序插入到MessageQueue。一般地，不需要唤醒事件队列，除非
//消息队头存在barrier，并且同时Message是队列中最早的异步消息。
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// 消息没有退出，我们认为此时mPtr != 0
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
MessageQueue是按照Message触发时间的先后顺序排列的，队头的消息是将要最早触发的消息。当有消息需要加入消息队列时，会从队列头开始遍历，直到找到消息应该插入的合适位置，以保证所有消息的时间顺序。
3) removeMessage:
方法顾名思义，从MessageQueue中移除消息：
void removeMessages(Handler h, int what, Object object) {
if (h == null) {
return;
}
synchronized (this) {
Message p = mMessages;
//从消息队列头部开始，移除所有符合条件的消息
while (p != null && p.target == h && p.what == what
&& (object == null || p.obj == object)) {
Message n = p.next;
mMessages = n;
p.recycleUnchecked();
p = n;
}
//移除剩余的符合要求的消息
while (p != null) {
Message n = p.next;
if (n != null) {
if (n.target == h && n.what == what
&& (object == null || n.obj == object)) {
Message nn = n.next;
n.recycleUnchecked();
p.next = nn;
continue;
}
}
p = n;
}
}
}
这个移除消息的方法，采用了两个while循环，第一个循环是从队头开始，移除符合条件的消息，第二个循环是从头部移除完连续的满足条件的消息之后，再从队列后面继续查询是否有满足条件的消息需要被移除。
4) postSyncBarrier和removeSyncBarrier
拦截同步消息和取消拦截，可以自行研究。
总结：MessageQueue就是一个链表结构的消息池，内部按照Message触发时间的先后顺序排列，提供基本的投递、获取、删除消息的功能。
2.3 Message
message 其实就是对消息封装的对象。针对它，主要了解的是消息池的概念，以及获取消息和回收消息的两个方法。
- 消息池：
message引入了消息池，这样的好处是，当消息池不为空时，可以直接从消息池中获取Message对象，而不是直接创建，提高效率。类似于设计模式中享元模式这么一个概念。
静态变量sPool的数据类型为Message，通过next成员变量，维护一个消息池；静态变量MAX_POOL_SIZE代表消息池的可用大小；消息池的默认大小为50。
- 消息池的主要操作obtain()和recycle()。
- obtain方法：从消息池中获取消息
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;//从sPool中取出一个Message对象，并让消息链断开
m.flags = 0; // 清除in-use flag
sPoolSize—;//消息池的可用大小进行-1操作
return m;
}
}
return new Message(); //当消息池为空，则直接创建Message对象
}
obtain(): 从消息池取Message，都是把消息池表头的Message取走，再把表头指向next;
- recycle方法：把不再使用的消息加入消息池
public void recycle() {
if (isInUse()) {//判断消息是否正在使用
if (gCheckRecycle) {// 版本>Android5.0 = true 版本<=Android5.0 = 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对象加入消息池
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;//消息池可用大小+1
}
}
}
recycle(): 将Message加入到消息池的过程，都是把Message加到链表的表头；
总结: Message 就是消息对象本身，内部有对象池，能一定程度优化频繁创建和销毁消息带来的性能问题。
2.4 Handler
Handler是消息处理者，由它发起消息操作。主要扮演了往MessageQueue上添加消息和处理消息的角色。
首先看看Handler的构造方法：
public class Handler {
final Looper mLooper;
final MessageQueue mQueue;
final Callback mCallback;
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper(); //默认关联当前线程的Looper
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;//关联当前线程Looper对应的MessageQueue
mCallback = callback;
mAsynchronous = async;
}
}
那么我们知道了，Handler在哪个线程被创建就属于哪个线程，就为哪个线程服务，因为关联的是当前线程的Looper，操作的也就是当前线程的MessageQueue
Handler发送和处理消息：
Handler最核心的功能就两个，一个是向MessageQueue发送消息，一个是处理MessageQueue分发出来的消息。
1) 发送消息：
handler有许多发送消息的方法：
post(Runnable)
postAtTime(Runnable, long)
postDelayed(Runnable, long)
sendEmptyMessage(int)
sendMessage(Message)
sendMessageAtTime(Message, long)
sendMessageDelayed(Message, long)
光看这些方法参数你可能会觉得handler能发两种消息，一种是Runnable对象，一种是message对象，这是直观的理解，但其实post发出的Runnable对象最后都被封装成message对象了。
以post（）方法为例：
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
最终还是封装成了Message,而且还是从Message的消息池里取的。
另外，这些发送消息的方法最终都会走到如下方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;//把当前msg的target与当前Handler一一对应
if (mAsynchronous) {//这个值是在Handler的构造方法中设置是否异步
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);//最终发送消息
}
2) 处理消息
消息的处理是通过核心方法dispatchMessage与钩子方法handleMessage完成的
在Looper的 loop() 方法中：
msg.target.dispatchMessage(msg); 也就是执行当前Hanlder的dispatchMessage(msg)方法：
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
都是回调方法的处理，逻辑很明显，不赘述了。
最后一张图看整个Java层面消息处理流程：
