好久没写文章了，刚好最近看了下Android消息机制的源码，上次看通透了，这次再看的时候忘记的差不多了，所以写下来。我将从Handler的使用开始分析Handler，已经与其密不可分的Loop、MessageQueeue、Message。
1. Handler的使用
我们平时使用Handler无外乎就是切换线程，处理延时任务，统一处理业务逻辑。我也在项目中见到通过Handler发送数据到其他类中，这种情况是不推荐使用Handler，应该使用回调。
代码清单1.1是Handler的创建方式
代码清单1.1
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 1: {
// ...
}
case 2: {
// ...
}
}
}
};
直接new一个Handler，重写它的handleMessage()方法，在handleMessage()方法中处理发送的message。
当然也有人通过重写dispatchMessage(Message msg)方法处理消息，如代码清单1.2，当然这里不推荐重写这个方法，原因会在后面分析中说明。
代码清单1.2
private Handler mHandler = new Handler() {
@Override
public void dispatchMessage(Message msg) {
super.dispatchMessage(msg);
switch (msg.what) {
case 1: {
// ...
}
case 2: {
// ...
}
}
}
};
上面这种通过重写dispatchMessage(Message msg)方法处理消息，可能大家见过，不推荐使用。不光这个方法，我们平时尽量不要重写系统API中dispatch开头的方法，除非你没有办法不重写，比如：dispatchTouchEnvent()，dispatchKeyEvent()等等，因为系统在dispatchXX()里面做分发的事情，可能因为你注释掉super.dispatch()或者返回true返回false，都会导致一些意想不到的事情发生。
再看看，我们是如何发送消息的？
代码清单1.3
//方式1 发送/延迟发送 一个空message,所谓的空，指的是message的obj、arg1、arg2是空
mHandler.sendEmptyMessage(1);
mHandler.sendEmptyMessageDelayed(1,1000);
Message msg = Message.obtain();
msg.what = 1;
//方式2 这种方式和上面的是一样的
mHandler.sendMessage(msg);
msg.obj = "this is message boj.";
// 方式3
mHandler.sendMessage(msg);
// 方式4 发送延时message
mHandler.sendMessageDelayed(msg, 1000);
// 方式5 指定时间发送
mHandler.sendMessageAtTime(msg, SystemClock.uptimeMillis() + 1000);
// 方式6 post Runnable
mHandler.post(new Runnable() {
@Override
public void run() {
}
});
2. Handler发送消息机制
代码清单1.3 是几种发送消息的方式，他们最终都是调用sendMessageAtTime()方法，如代码清单2.1。
代码清单2.1 类
Handler.java
public class Handler {
public final boolean sendEmptyMessage(int what){
return sendEmptyMessageDelayed(what, 0);
}
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
}
可以看到，最终都调用到第27行的sendMessageAtTime()方法，这个方法又调用了enqueueMessage()方法。不用看enqueueMessage()方法，我们也可以猜到，这个方法是向队列MessageQueue中添加数据，实际也确实如此，MessageQueue是一个基于单链表的队列（并且是按照发送时间从小到大排序），队列有两种基本操作：入队 enqueue()，放一个数据到队列尾部；出队 dequeue()，从队列头部取一个元素。
栈也有两种基本操作：入栈 push()和出栈 pop()。
好了，让我们看看enqueueMessage()方法，代码清单2.2。
代码清单2.2 Handler#enqueueMessage()
public class Handler {
// ...省略其他方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
}
代码清单2.2，第4行msg.target = this;给Message绑定了当前对象Handler，指针指向target（即Handler的引用指向Message的成员变量target）。最后调用了MessageQueue#enqueueMessage()，这个方法是向队列中添加数据。
代码清单2.3 MessageQueue#enqueueMessage()
public final class MessageQueue {
Message mMessages;
boolean enqueueMessage(Message msg, long when) {
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) {
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) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
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;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
}
这个方法比较长，前面是对Message合法性的判断，我们只关注第24到49行，我把他们单独摘出来放在代码清单2.4中，方便你阅读。
代码清单2.4
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
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;
}
第1行，将类型为Message的成员变量mMessage赋值给临时变量p。mMessage是单链表的一个节点（实际上是单链表的头节点）。
第3行if条件，if(p == null || when == 0 || when < p.when)表示，if(当单链表为空时 || 当前消息的发送时间点是0 || 当前消息的发送时间小于链头消息的时间)，当满足这个条件时，直接讲消息插到链头，5到7行是把消息插入链头的操作。
第9到22行，是一个死循环，退出循环的条件是if (p == null || when < p.when)表示if(已经遍历到最后一个节点 || 消息的时间小于下个节点的时间)，其实就是通过循环找到了，消息插入链表的位置，使得链表按照发送时间升序排序。
单链表结构如下图：
代码虽然长了点，但实际实现的就是维护一个图1.1所示的按照when升序排序的单链表，每次插入新的元素都需要保证单链表的有序性，这样当我们发送消息时只需要按照链表的顺序去发送就可以了。
以上就是Message在MessageQueue中的入队操作，我们再看看，出队操作，定义在方法next()中，如代码清单2.5
代码清单2.5 MessageQueue#next()
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
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 {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}
出队的代码也很长，不过我们没有必要细抠每一行。这个方法返回一个Message对象，在代码清单2.5中，我们找return 相关的语句，在第43行。我们还是把关键的一部分逻辑摘出来，方便你阅读。
代码清单2.6 MessageQueue#next()
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
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 {
// No more messages.
nextPollTimeoutMillis = -1;
}
根据之前我们的分析，msg.target是发送这个Message的Handler，如果这个handler是null，就会去获取下一个异步节点。
请注意第2行Message msg = mMessages;第20行mMessages = msg.next;第22行msg.next = null;这三行代码，这是拿到头节点，并且把头节点从链表中摘除，最后返回这个头节点的代码。mMessages代表链表，是链表头节点的引用，第2行将其用临时变量msg保存，相当于msg保存了链表的头节点，第20行将链表的头节点的下一个节点指向当前链表mMessage，第22行，让头节点的下个指针指向null，这样就把头节点从链表mMessage中摘除了。
这块属于链表的操作，讲的可能不是很清除，大家要认真体会。
总结，MessageQueue保存了所有的消息，每次发送消息，将消息添加到了队列的合适位置保证链表按照when从小到大排序，每次去拿消息，都是从链表的头部获取。
3 消息处理机制
我们介绍了消息发送的机制，那么消息是什么时候处理的？以及如何处理的？
以主线程消息处理为例，我们知道ActivityThread的main()方法是应用的入口，main方法中部分代码如下：
代码清单3.1 ActivityThread#main()
public static void main(String[] args) {
Looper.prepareMainLooper();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
}
Looper.prepareMainLooper()创建了主线程的Looper对象，并将其存储在常量sThreadLocal中。
代码清单3.2 Looper.java
static final ThreadLocal sThreadLocal = new ThreadLocal();
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
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));
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
private Looper(boolean quitAllowed) {
// Looper的构造方法中会创建MessageQueue
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到，prepare()方法中，第17行用于创建Looper对象，并将Looper对象存在sThreadLocal中，ThreadLocal是以线程为单位存储泛型对象的类，比如线程1给ThreadLocal
代码清单3.1 第9行，Looper.loop()则是开始主线程消息循环，不断从MessageQueue中获取消息，如果MessageQueue中无消息，则会阻塞。代码清单3.3 是Looper的loop()方法。
代码清单3.3 Looper#loop()
public static void loop() {
final Looper me = myLooper();
// 省略部分代码
final MessageQueue queue = me.mQueue;
boolean slowDeliveryDetected = false;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
// ...省略部分代码
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
// ...
try {
msg.target.dispatchMessage(msg);
if (observer != null) {
observer.messageDispatched(token, msg);
}
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} catch (Exception exception) {
if (observer != null) {
observer.dispatchingThrewException(token, msg, exception);
}
throw exception;
} finally {
ThreadLocalWorkSource.restore(origWorkSource);
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
// ...
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// 省略部分代码
msg.recycleUnchecked();
}
}
第6行表示，loop方法是一个死循环，第7行会调用MessageQueue的next()方法，即从MessageQueue中去拿消息，如果MessageQueue中没有消息，则阻塞。
第24行，msg.target.dispatchMessage(msg);是分发消息，这行是真正的处理消息，关于处理消息机制，下面部分讲解，我们可以看到分发消息前后都有调用logging.printLn()方法，而logging对象我们可以通过setMessageLogging()方法设置，这就给我们提供了一个思路：我们可以通过自定义logging，来获取一次消息处理的耗时时间。
4 处理消息机制
回过头来，我们再看代码清单3.3中第24行的msg.target.dispatchMessage(msg);
前面，我们说了Message的target是发送它的Handler，那么处理消息是从Handler#dispatchMessage()方法开始。
代码清单4.1
Handler#dispatchMessage()
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(@NonNull Message msg) {
}
msg.callback又是什么呢？什么情况下callback!=null
还记得前面我们讲Handler发送消息的几种方式，其中post()方法也是发送消息，如下：
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可见，只有通过post()方法发送消息，callback才被赋值，callback指向Runnable实例。
继续看代码清单4.1，当是通过post()方法发送的消息，则会执行handleCallback(msg);方法，第15行中，handleCallback(msg);方法中会调用Runnable#run()方法，run()方法中就是我们要处理的逻辑。
当是通过sendMessageXXX()方式发送的消息时，会调用handleMessage()方法，源码中这个方法是个空方法。这个方法就是我们创建Handler时重写的方法，用于处理我们自定义的消息。
源码中dispatchMessage和handleMessage()两个方法参数一样，并且都是public类型的方法，都可以被重写。前面我们说不要重写的dispatchMessage()方法，就是因为dispatchMessage()方法内部区分是否是post()的消息。如果使用不当，则会导致Handler#post()方法失效，像下面的代码。
代码清单4.2 演示post()方法失效，实际中不要这么干
private Handler mHandler = new Handler() {
@Override
public void dispatchMessage(@NonNull Message msg) {
// super.dispatchMessage(msg);
switch (msg.what){
//处理消息
}
}
};
5 子线程中的Handler
前面我们分析，主线程的Looper在ActivityThread的main()方法中初始化，所以我们在主线程可以通过无参的构造器创建Handler。如果在子线程（未初始化Looper）中通过无参的构造器创建Handler，则会抛出RuntimeException，如代码清单5.1，因为子线程未初始化Looper，导致Looper.myLooper();为空。
代码清单5.1 Handler.java
public class Handler {
public Handler() {
this(null, false);
}
public Handler(@Nullable Callback callback, boolean async) {
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
}
那么在子线程中创建Handler是不是可以像代码清单5.2这样。
代码清单5.2 子线程创建Handler
public class Test extends Thread{
private Handler mHandler;
@Override
public void run() {
super.run();
Looper.prepare();
mHandler = new Handler(){
@Override
public void handleMessage(@NonNull Message msg) {
// 处理消息
}
};
Looper.loop();
}
}
理论上可以这样，不过Android提供了更好的方式，HandlerThread
代码清单5.3 HandlerThread.java
public class HandlerThread extends Thread {
protected void onLooperPrepared() {
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
@NonNull
public Handler getThreadHandler() {
if (mHandler == null) {
mHandler = new Handler(getLooper());
}
return mHandler;
}
}
HandlerThread继承自Thread类的源码很简单，这里不再赘述。
如果我们在需要子线程处理任务，那么只需要执行：
HandlerThread.getThreadHandler().post(new Runnable(){
// 执行任务
})
但是如果我们想发送消息，在handleMessage()方法中处理消息怎么办？
不知道你有没有注意，Looper的loop()方法中从一开始到消息（Message msg = queue.next();）到分发消息msg.target.dispatchMessage(msg);再到处理消息handleMessage()，中间没有切换线程。这也就是说，handleMessage()在哪个线程中执行，取决于调用loop()所在的线程。
有了这个结论，那么我们创建子线程的Handler是不是可以这样：
private Handler mHandler;
private void test() {
HandlerThread ht = new HandlerThread("thread-id");
ht.start();
mHandler = new Handler(ht.getLooper()) {
@Override
public void handleMessage(@NonNull Message msg) {
// 处理子线程消息
}
};
}