Android消息处理机制：十分钟让你明白消息处理机制
引言
Android消息机制肯定是最被经常提起的一个概念，通过下面的文章希望大家可以理解Message、 Handler、Looper。
1 消息处理流程
在子线程中更新UI，先使用Handler的sendMessage去发送Message对象，然后通过Handler的handleMessage()方法中获得刚才发送的Message对象，这就是一个消息处理流程，是常用的一种情况。
new Thread(new Runnable() {
@Override
public void run() {
Message message = Message.obtain();
mHandler.sendMessage(message);
}
}).start();
mHandler =new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});
2 Message
Google官方建议实例化Message时使用obtain方法，而不是直接new Message。因为Message维护着一个对象池，使用obtain方法能够复用之前被回收的Message，下面代码 if 语句就是复用Message。
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();
}
而Message的回收是调用了方法recycleUnchecked，可以看出来对象池有最大数量（MAX_POOL_SIZE）它的值是50，并且对象池是一个单链表，单链表的优势就是方便插入、删除和节约内存。
private static final int MAX_POOL_SIZE = 50;
void recycleUnchecked() {
省略掉部分初始化代码……
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next =sPool;
sPool =this;
sPoolSize++;
}
}
}
3 Handler
为了防止内存泄漏，将Handler声明为静态类。一般情况下，通过Handler的sendMessage方法发送Message，最后调用msg.dispatchMessage(msg)回调到handleMessage方法。
static class MyHandler extends Handler {
WeakReference mWeakReference;
public MyHandler(Activity activity){
mWeakReference=new WeakReference(activity);
}
@Override
public void handleMessage(Message msg) {
final Activity activity=mWeakReference.get();
if(activity!=null) {
//
}
}
}
}
3.1 Handler构造方法
Handler有七个构造方法，不难看出①②③最后都会调用④。然后通过 Looper.myLooper()获取到Looper对象，再通过mLooper.mQueue获取到MessageQueue对象，最后我们会调用sendMessage方法发送Message对象到MessageQueue中。
① 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) {
if (FIND_POTENTIAL_LEAKS) {
final Class 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;
}
查看myLooper的源码不难看出，myLooper是从sThreadLocal中获取到该线程下的Looper。
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
构造方法⑤⑥最终会调用⑦，它们和前面四种构造方法不同之处在于可以指定Looper。
⑤ 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) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
3.2 sendMessage方法
创建完Handler对象之后，通过sendMessage发送对象，不难看出最后调用了sendMessageAtTime方法，通过MessageQueue queue = mQueue取得构造Handler时所获得的MessageQueue对象。
源码中还有几个发送消息的方法就不一一讲解了。
public final boolean sendMessage(Message msg){
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis){
if (delayMillis <0) {
delayMillis =0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
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);
}
通过enqueueMessage方法将Message加入MessageQueue 中，阅读源码发现Handler方法发送的Message最后都要到MessageQueue中。
msg.target其实就是Handler自己，它的作用是用来调用自己的dispatchMessage方法，在Looper的loop方法中会说到。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target =this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
3.3 dispatchMessage
调用dispatchMessage方法时会判断msg是否有callback，而这个callback就是Runnable，通过对post的讲解你就会明白是怎么回事。
public void dispatchMessage(Message msg) {
if (msg.callback !=null) {
handleCallback(msg);
}else {
if (mCallback !=null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
我们经常会用到post，这个post并非真的创建新线程， 而是将Runnable封装到Message中。
mHandler.post(new Runnable() {
@Override
public void run() {
}
});
public final boolean post(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
阅读dispatchMessage源码发现，如果callback不为null就调用handleCallback，callback为null则调用handleMessage。可以看在出来post中的Runnable最后会在handleCallback中执行它的run方法，并没有创建新的线程去执行run。
private static void handleCallback(Message message)
message.callback.run();
}
4 Looper
有了Message和Handler，但是还有在一个问题，3.1中说到的从sThreadLocal中获取Looper，这个Looper是谁保存到sThreadLocal中的？其实就是Looper创建时保存的。
在Looper这个类中有两个重要的方法，分别是prepare和loop方法。prepare负责创建Looper，loop负责无限循环读取消息。
4.1 prepare
Looper的prepare方法可以去实例化一个Looper，通过sThreadLocal.set(new Looper(quitAllowed))这行代码可以看出来，prepare创建了一个Looper加入到sThreadLocal中。
public static void prepare() {
prepare(true);
}
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时就会创建MessageQueue，所以MessageQueue并不需要我们手动创建。通过上面的 if 语句可以看出，一个线程里只能有一个Looper，否则会抛出"Only one Looper may be created per thread"，因此MessageQueue在一个线程中也只能有一个。
通过下面的代码我们也可以得出另一个结论，在子线程中必须先调用looper.prepare才能使用handler，否则handler会无法发送消息，因为没有MessageQueue。
private Looper(boolean quitAllowed) {
mQueue =new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
4.2 loop
一般在子线程中是这么使用loop的。先使用Looper.prepare()创建Looper，然后发送消息，最后再使用Looper.loop()无限循环读取消息回调到handleMessage。
Looper.prepare();
Message message = Message.obtain();
mHandler.sendMessage(message);
Looper.loop();
loop的源码比较长，只分析关键点，完整源码请自行查看。
首先通过myLooper获取到Looper对象。
从下面的代码可以看出Looper不能为null不然会抛出"No Looper; Looper.prepare() wasn't called on this thread."，所以loop方法必须在Looper.prepare方法后使用。
final Looper me =myLooper();
if (me ==null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
loop方法是通过me.mQueue取得MessageQueue的。
final MessageQueue queue = me.mQueue;
那么，loop是怎么实现无线循环的呢？关键就在于它的for循环。
然后通过queue.next()去MessageQueue中获取消息，接着使用msg.target.dispatchMessage(msg)去分发消息（msg.target就是前面在讲Handler时说到的Handler本身），至此一个消息处理流程就分析完了。
for (;;) {
Message msg = queue.next(); // might block
if (msg ==null) {
// No message indicates that the message queue is quitting.
return;
}
try {
msg.target.dispatchMessage(msg);
}
}
五 整体流程总结
图5-1 流程图
首先由Looper.prepare创建Looper，Looper会创建MessageQueue，因为一个线程只有一个Looper，所以一个线程只有一个MessageQueue。
接着创建Message，创建Message对象使用obtain方法，而不是直接new出来，因为Message内部维护这一个对象池，可以复用之前已经使用过的Message对象，如果线程池为null会创建一个新的Message（new Message）。
再接着创建一个Handler，调用sendMessage发送Message到MessageQueue（MessageQueue并非真正的队列，而是一个单链表）。
最后调用Looper.loop循环读取消息，并调用Handler的dispatchMessage进行回调处理。回调完之后调用msg.recycleUnchecked方法将msg加入到Message维护的对象池中。
