前言
说到Android的消息队列，大家或多或少都能说个大概，原理啥的在网上一搜就是一大堆。记得之前刚毕业有次面试的时候被问到这个问题，当时我也只是从网上了解到原理，就按照记忆说了。后来面试官又补充问了一句，Handler有什么用，我说，可以在别的线程更新主线程UI。他问还有么，我一脸懵逼。好了，闲扯到此，本文带大家从源码角度看看Handler机制的实现与到底有什么用。
一、Handler的简单使用
直接上代码：
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case 0x1:
// 更新UI
break;
}
}
};
Message message = handler.obtainMessage();
message.what = 0x1;
handler.sendMessage(handler.obtainMessage());子线程通知UI更新，这是最基本的使用，相信大家刚学Android的时候都是这么玩的。还有一种：
handler.postDelayed(new Runnable() {
@Override
public void run() {
// to do something
}
}, 3000);这个方法是延迟3s后再执行操作。其实，不严格来说，在IPC中还有一种Messager机制，也是使用Handler的方式实现，有兴趣大家可以了解一下。但是其本质还是上述的方法，只是基于AIDL实现了跨进程通信。
二、源码解析
1. Handler
先来看看Handler的类注释。
Handler用于发送和处理与该线程（创建Handler对象的线程）的MessageQueue相关联的Message与Runnable对象。Handler对象在创建时与创建它的线程及该线程的MessageQueue关联。Handler可以发送Message到该MessageQueue队列并在出队列时处理任务。
Handler有两个用途：1）调度message和runnable到以后特定时间执行；2）在不同的线程将Message入队列到创建它的线程执行。
通过一系列的post与sendMessage方法来调度任务。post方法将Runnable对象加入队列，sendMessage方法将Message对象加入队列，之后通过handler的handleMessage方法来处理，因此要重写Handler的该方法。可以指定Message在消息队列准备好处理它时立即处理，也可以指定延迟或特定时间时处理。
首先来看一下Handler如何与线程的MessageQueue关联，其构造方法如下：
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();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}mLooper = Looper.myLooper()；首先获取到该线程的looper对象，如果没有则说明还有初始化looper，会抛出异常。之后则将looper的mQueue赋给handler的mQueue引用。完成handler与MessageQueue的绑定。
post与sendMessage发送消息
在源码中，可以看到，4个post方法与5个sendMessage方法最终都调用了sendMessageAtTime(Message msg, long uptimeMillis)方法。只有postAtFrontOfQueue(Runnable r)方法调用了sendMessageAtFrontOfQueue(Message msg)。而两者最终都调用了enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)方法。
所有的5个post方法都通过getPostMessage(Runnable r)将Runable对象封装成Message对象。该方法如下：
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}该方法通过Message.obtain()获取Message实例，将Runable对象置于message的callback引用下。
最后看一下这个enqueueMessage(Message msg, long when)方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}可以看到首先就将Handler实例的引用放到了Message的target中，方便在处理时取出handler进行处理，但是这样就会造成另一个问题，就是内存泄漏。一般我们会在handler中更新UI控件，但是这些控件会引用创建它们的Activity，因此像上述这样做法就会导致Activity实例无法释放回收内存，一般这种情况，会采用对Activity使用弱引用的方法，这个下文再提一下实现。
最后又调用了MessageQueue的enqueueMessage方法将message加入队列。
dispatchMessage分发处理消息
public void dispatchMessage(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(Message msg) {
}这个方法是Looper调用来处理Message用的，这个Looper我们后面再说，先看这个方法实现。首先判断Message中的callback引用是否为空，如果不为空，则直接执行callback。这个callback就是上面post方法传递来的参数。而如果不存在callback，就在下面执行handleMessage(msg)方法，这个方法就很熟悉了，我们定义Handler都要重写handleMessage(Message message)方法，该方法实现为空，注释上说明了，子类要实现该方法来接收Message。当然，handleMessage之前还有个Handler的Callback非空判断，这是在定义Handler时传来的参数，如果该Callback执行结果为true，则所有该Handler的sendMessage发来的Message都不会被执行，而是被该Callback拦截掉。
2.MessageQueue与Message
MessageQueue
MessageQueue类是持有由Looper分发的message列表的类，Message不是直接添加到MessageQueue中，而是通过Handler对象实现添加。可以通过Looper的myQueue()方法获取到当前线程的MessageQueue。该类使用了很多native方法，涉及到底层实现。（尴尬，C和C++都还给老师了）
Message
Message类则定义了一个包含描述与任意数据对象的消息类，可以发送给Handler。包含两个额外的int和一个Object对象引用，这俩并不是一定要分配对象。当然，还有what等变量。我们一般会在waht中放辨识消息的标志，在obj中放要传递的消息内容。
尽管Message构造方法是public的，但是还是建议使用Message.obtain()方法。
看一下实现：
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}使用同步代码，如果当前的sPoll不为空，则取出当前的Message对象，sPoll指向Message的next引用。否则会new一个新Message对象出来。
还有就是recycleUnchecked()：
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
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) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}代码很简单，将Message对象的各个变量进行数据清空，之后则将该Message添加到sPool中。
通过创建与回收的代码可以看到，Message采用链表结构进行存储与复用。正如上文提到的使用享元模式可以循环利用这些对象，实现Message对象的循环使用，避免重复创建。
3. Looper
最后来看看Looper。
相信大家在初学时，肯定也干过在子线程创建Handler抛出异常的事。其实很简单，看看代码就晓得了。
首先看一下注释。
为线程循环执行message的类。线程默认没有looper关联，要使用prepare方法创建并调用loop方法来处理message。
主要的方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}首先构造方法中创建了MessageQueue，然后获取到当前线程的引用，但是该方法是private权限的，因此只有内部可以访问，这里就要涉及到上面说的prepare方法了。
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，如果包含了则抛出只能初始化一次的异常。如果不包含的话，则创建Looper并绑定到当前线程中。
而通过myLooper()与myQueue()方法则可以获取到当前线程绑定的looper以及该looper绑定的MessageQueue。
loop
Looper类最重要的方法莫过于loop()方法，用于循环分发处理Message。
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
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);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();
}
}分析一下代码：
首先获取当前线程的Looper，如果不存在则抛出异常。然后获取到线程绑定的MessageQueue对象。之后开始了无限循环从消息队列中取出消息加以处理。
取出消息的时候Message msg = queue.next()方法，可能会发生阻塞。如果没有message则消息队列退出。之后则调用msg.target.dispatchMessage(msg);来进行处理Message。而我们在分析Handler时发现，target变量中存放的就是Handler对象。Handler的dispatchMessage方法上面也分析过了，这样就实现了消息的处理。在最后调用msg.recycleUnchecked()方法对Message进行数据清理复用。
这四个类就分析到这里。
三、问题与总结
1. 主线程为何不要Looper.preapre()与Looper.loop()
这个，相信很多人都是知道的，提一下，就是在ActivityThread的main方法中（管理应用程序主线程的执行，相当于普通java程序的main入口）执行了prepare与loop。如下：
Looper.prepareMainLooper();
...
Looper.loop();2. 使用内部类的形式定义Handler造成的问题
如果大家够严谨的话，会发现如果使用内部类形式定义一个Handler，编译器会发出警告，就是内存泄漏的问题。如图：
这里大概就是说，如果内部类使用外部类的引用，会造成内存泄漏，解决方法有：使用静态内部类（这样引用到的外部类还是得弱引用）；使用外部类，且使用到的Activity引用为弱引用；使用内部类但对所有引用到的外部类成员使用弱引用。
具体解决代码如下：
private static class MyHandler extends Handler {
WeakReference<MainActivity> mActivityWeakReference;
public MyHandler(Activity activity) {
mActivityWeakReference = new WeakReference<>(activity);
}
@Override
public void handleMessage(Message msg) {
MainActivity activity = mActivityWeakReference.get();
if (activity != null) {
switch (msg.what) {
case 0x1:
// 更新UI
break;
}
}
}
};弱引用的特点，就是相对于强引用，当GC回收时，如果仅有一个弱引用指向该对象，则会回收该对象。这样当activity被关闭之后，就可以及时回收，而不用担心内存泄漏。
3.总结
总结一下Android消息队列的实现原理。首先在新线程中（包括主线程，系统做好了）调用Looper.preapre()，初始化线程的Looper与MessageQueue，之后调用Looper.loop()循环从MessageQueue中取出Message并调用绑定的Handler执行dispatchMessage方法分发处理。而使用Handler把Message发送到MessageQueue队列中，同时也会把Handler绑定到Message中。
从中我们可以收获以下知识：
- Android消息队列理解；
- 消息队列的实现；
- 享元模式实现对象复用，节省内存资源；
- 弱引用避免内存泄漏；
OK，就这么多了。
