Android异步消息处理机制(2)源码解析
上一章讲解了Android异步消息处理机制的基本使用，下面将简单地探寻一下异步机制背后的奥妙，源码版本为：API22。
首先，声明一下本文是在我参考了一下各位大神的文章之后才慢慢熟悉的， 若有不足之处，还望各位批评指正！。菜鸟上路，，，，
郭霖博客
鸿洋博客
刘超 深入解析android5.0系统
任玉刚博客
先后顺序按照拼音排序，无关技术本身。
先简单地总结一下Looper，MessageQueue，Message和Handler四者之间的关系：
- Looper和MessageQueue
Looper对象是线程的消息循环处理器，每个线程只能有一个Looper。Looper内部有一个消息队列MessageQueue对象，所有该线程的消息都存放在该队列（按照时间排序）中，Looper不断从MessageQueue中取出消息，然后调用消息对应的Handler进行处理消息。android在启动时为主线程（UI线程）自动创建一个Looper对象，而我们自己创建线程时必须要创建Looper对象（调用Looper.prepare()）。 - Handler（非抽象类）
Handler对象是Message对象的接收者和处理者。用户通过Handler把消息添加到消息队列，同时通过Handler的回调方法hanldeMessage()处理消息。Hanlder在构造时和一个Looper对象关联在一起。Handler和Looper是多对一的关系，多个Handler对象可以和同一个Looper对象建立关系，反之则不行。 - Message
Message是消息的载体，是Parcelable的派生类。
四者涉及到的主要成员变量和方法
Looper类的主要成员变量和方法：
public final class Looper { // 成员变量 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); private static Looper sMainLooper; final MessageQueue mQueue; final Thread mThread; // 成员方法 public static void prepare() {...} private static void prepare(boolean quitAllowed) {...} public static void prepareMainLooper() {...} public static Looper getMainLooper() {...} public static void loop() {...} public static Looper myLooper() {...} public static MessageQueue myQueue() {...}}MessageQueue类中的主要成员方法：
public final class MessageQueue { Message next() {...} boolean enqueueMessage(Message msg, long when){...}}Handler类中的主要成员变量和方法：
public class Handler { //内部接口 public interface Callback { public boolean handleMessage(Message msg); } //处理消息相关方法 public void handleMessage(Message msg) {} public void dispatchMessage(Message msg) {...} private static void handleCallback(Message message) {...} // 构造器相关方法 public Handler() {...} public Handler(Callback callback) {...} public Handler(Looper looper) {...} public Handler(Looper looper, Callback callback) {...} public Handler(boolean async) {...} public Handler(Callback callback, boolean async) {...} public Handler(Looper looper, Callback callback, boolean async) {...} // 获取Message相关方法 public final Message obtainMessage(){...} public final Message obtainMessage(int what){...} public final Message obtainMessage(int what, Object obj){...} public final Message obtainMessage(int what, int arg1, int arg2){...} public final Message obtainMessage(int what, int arg1, int arg2, Object obj){...} // post相关方法 public final boolean post(Runnable r){...} public final boolean postAtTime(Runnable r, long uptimeMillis){...} public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){...} public final boolean postDelayed(Runnable r, long delayMillis){...} public final boolean postAtFrontOfQueue(Runnable r){...} // send相关方法 public final boolean sendMessage(Message msg){...} public final boolean sendEmptyMessage(int what){...} public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {...} public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {...} public final boolean sendMessageDelayed(Message msg, long delayMillis){...} public boolean sendMessageAtTime(Message msg, long uptimeMillis) {...} public final boolean sendMessageAtFrontOfQueue(Message msg) {...} // 进出消息队列 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {...}}Message类中的主要成员变量和方法：
public final class Message implements Parcelable { // 主要成员变量 public int what; public int arg1; public int arg2; public Object obj; public Messenger replyTo; private static final Object sPoolSync = new Object(); private static Message sPool; private static int sPoolSize = 0; private static final int MAX_POOL_SIZE = 50; // 主要成员方法 public Message() {} // 不建议使用 // 获取Message相关方法 public static Message obtain() {...} public static Message obtain(Message orig) {...} public static Message obtain(Handler h) {...} public static Message obtain(Handler h, Runnable callback) {...} public static Message obtain(Handler h, int what) {...} public static Message obtain(Handler h, int what, Object obj) {...} public static Message obtain(Handler h, int what, int arg1, int arg2) {...} public static Message obtain(Handler h, int what, int arg1, int arg2, Object obj) {...} public void setTarget(Handler target) {...} public void sendToTarget() {...} public Handler getTarget() {...}}下面将以问答的方式解析异步消息处理机制。
问答解析
1. ThreadLocal的作用？
解析：ThreadLocal是Thread Local Variable即线程本地变量的意思，通过把数据放在ThreadLocal中就可以让每个线程创建一个该变量的副本，从而避免并发访问的线程安全问题。这里保存Looper类的实例对象。
2. 为什么在UI线程中实例化Handler并不需要Looper.prepare()，而在子线程中则需要Looper.prepare()？
解析：这是因为在ActivityThread类中的main()方法调用了Looper.prepareMainLooper()，简单代码如下：
public static void main(String[] args) { ...// 前面的省略了 Looper.prepareMainLooper(); ActivityThread thread = new ActivityThread(); thread.attach(false); if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } if (false) { Looper.myLooper().setMessageLogging(new LogPrinter(Log.DEBUG, "ActivityThread")); } Looper.loop(); throw new RuntimeException("Main thread loop unexpectedly exited"); }可以看到main()方法中调用了Looper.prepareMainLooper()，而Looper.prepareMainLooper()源码为：
public static void prepareMainLooper() { prepare(false); synchronized (Looper.class) { if (sMainLooper != null) { throw new IllegalStateException("The main Looper has already been prepared."); } // 若不存在Looper对象，则从sThreadLocal获取 sMainLooper = myLooper(); } }而prepare(boolean)代码如下：
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)); }到这里我们可以看到main()方法中调用了Looper.prepareMainLooper()，而Looper.prepareMainLooper()又调用了prepare(boolean)。prepare(boolean)方法就会创建一个Looper对象并保存在静态变量sThreadLocal（ThreadLocal类实例）。我们来看一下Looper的构造器：
private Looper(boolean quitAllowed) { mQueue = new MessageQueue(quitAllowed); mThread = Thread.currentThread(); }该构造器为私有的，且创建了一个消息队列实例，并将当前线程保存下来。
同时在prepare(boolean)可以看到若sThreadLocal已经有一个Looper对象后再创建就会出现异常。这说明了两点：1. 一个线程中只能有一个Looper对象；2. 一个线程中只能最多调用一次prepare相关的方法（prepare()（内部也是调用prepare(boolean)），prepare(boolean)，prepareMainLooper()（UI线程中调用），）。
而我们在子线程中调用的是Looper.prepare()，来看一下这个方法的源码：
public static void prepare() { prepare(true); }可以看到同样也是调用了prepare(boolean)。
3. 实例化Handler系统为我们做了哪些事情？
解析：该问题主要涉及到Handler中以下几个方法：
public Handler() {this(null, false);}public Handler(Callback callback) {this(callback, false);}public Handler(Looper looper) {this(looper, null, false);}public Handler(Looper looper, Callback callback) {this(looper, callback, false);}public Handler(boolean async) {this(null, async);}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; }public Handler(Looper looper, Callback callback, boolean async) { mLooper = looper; mQueue = looper.mQueue; mCallback = callback; mAsynchronous = async; }在上述构造器中可能传递的参数为：
- Looper对象，用于指定Handler将消息发送到的Looper对象。因此在实例化Handler对象之前需要调用
Looper.prepare()方法。 - Callback接口对象，用于处理Handler发送的消息。
- boolean值，是否是异步操作。针对Handler来说这里都是传递的false。
首先，在Handler(Callback callback, boolean async)中我们看到调用了Looper.myLooper()返回Looper对象，若Looper对象为null则会抛出异常。
根据以上构造器，我们能够有多种方式实例化一个handler对象，前五个构造器最终都会调用下面两个构造器。对于Handler(Callback callback, boolean async)这个构造器没有指定Handler的Looper对象，则使用当前线程的Looper对象。同时我们看到传递了Callback接口对象，将其值赋值给了mCallback，我们来看一下相关的源码：
public interface Callback {public boolean handleMessage(Message msg);}final Callback mCallback;public void dispatchMessage(Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }通过上述代码我们可以看到，若传递Callback接口对象的话，在dispatchMessage(Message msg)中将不会执行handleMessage(msg)（当然这之前先判断msg.callback是否为空，这个问题之后再讲），而是调用mCallback.handleMessage(msg)，而该方法就是我们传递的Callback接口对象实现的方法。因此，我们也可以通过这种方式处理消息。若不传递Callback接口对象的话，那么就会执行handleMessage(msg)，我们可以通过继承Handler实现该方法处理消息。
4. 实例化Handler对象之后，为什么要调用Looper.loop()?
为了解决这个问题我们先看一下loop()源码：
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; ..... for (;;) { // 取一条消息，没有就会阻塞 Message msg = queue.next(); // might block if (msg == null) { // msg等于null，就会退出 return; } ..... msg.target.dispatchMessage(msg); ..... msg.recycleUnchecked(); // 保证消息循环利用。 } }在loop()中首先获取Looper对象me，然后根据该对象获取对应的消息队列queue，下面就进入一个for(;;)死循环不断地从queue取消息，若没有则next()（该方法比较复杂，我没怎么看懂，，，）方法就会阻塞。
若消息为空的话就会退出loop()；下面有一句：msg.target.dispatchMessage(msg);，这个消息msg的target属性就是Handler对象，那么这个消息就是由该Handler来处理的。我们可以通过Message的重载方法obtainXXX()和setTarget()设置Handler对象。
通过loop()，就能实现不断处理发送过来的消息。
我们再来看一下Message的sendToTarget():
public void sendToTarget() { target.sendMessage(this); }可以看到通过这个方法发送消息和通过Handler发送消息一样。
5. Handler中的sendMessage()是如何将消息发送到消息队列中的，而消息队列又是如何管理消息的？
首先，看一下，send相关方法：
// send相关方法public final boolean sendMessage(Message msg){...} // 发送的消息希望及时处理，但不插队public final boolean sendEmptyMessage(int what){...} // 只发送带有what属性的消息，希望消息及时处理即可public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {...} // 希望延迟处理public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {...} // 希望消息在指定的时间处理public final boolean sendMessageDelayed(Message msg, long delayMillis){...} // 希望延迟处理public boolean sendMessageAtTime(Message msg, long uptimeMillis) {...} // 希望消息在指定的时间处理public final boolean sendMessageAtFrontOfQueue(Message msg) {...} // 消息插队，希望马上处理带有Empty的方法甚至发送的不是消息，只是what！！注意一下。
上面的send方法，除了sendMessageAtFrontOfQueue(Message)，都会调用sendMessageAtTime(Message,long)。而这两个方法中则会返回消息队列的enqueueMessage(Message,long)的方法，该方法就是将消息按照时间顺序插入到消息队列中。其实，消息队列是用链表实现的，排序方式是按照时间进行排列的。enqueueMessage(Message,long)源码如下：
boolean enqueueMessage(Message msg, long when) { .... synchronized (this) { .... msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; if (p == null || when == 0 || when < p.when) { 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; } .... } return true; }可以看到首先通过if判断插入的消息的时间是否最小，若是的话直接插入到链表头部，否则进入for(;;)依次遍历链表直到时间小于链表值，然后再插入。消息队列以mMessages为表头进行保存。
以上方法就通过Handler的send方法将消息插入到消息队列中。此时还是在同一个线程中。
6. 线程之间是如何转换的？
- 在A线程中实例化Handler对象之后，调用
loop()方法循环检测是否有消息进入队列，若有则取出并处理； - 在B线程中，通过Handler对象的
sendMessage()方法发送消息，发送过来的消息通过一系列的处理进入到消息队列，这样消息就进入了A线程中。
通过上述两步实现了A线程和B线程之间的通信。
7. 创建消息的方式
创建消息的方式有很多种，我们来对比一下：
- Handler的
obtainMessage()系列； - Message的静态方法
obtain()系列； - 使用构造器创建。
Handler中的方法实际上都是调用Message的静态方法obtain()系列，而obtain()系列最终都会调用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(); }可以看到当前存在多余的消息时，则我们可以直接使用，而不是再创建一个新的消息，循环使用消息减少资源浪费。能够循环使用消息的原因是：每当处理完一个消息时都会调用消息的recycleUnchecked()该方法就会将使用过的消息进行保存。源码如下：
void recycleUnchecked() { ... // 清空消息内容 synchronized (sPoolSync) { if (sPoolSize < MAX_POOL_SIZE) { next = sPool; sPool = this; sPoolSize++; } } }sPool是静态成员变量，保存链表的头，当处理过一个消息时，（消息池大小小于给定值50时）该消息就会采用头插法插入链表中。
8. Handler的post方法是干什么用的？
我们首先回过头来看一下dispatchMessage()方法，其中有一个判断：
if (msg.callback != null) { handleCallback(msg);}只有当msg.callback为空时才会执行下面的。消息的callback属性是Runnable变量，那么该属性是在哪里赋值的呢？我们发现在post系列中都会调用一个方法getPostMessage():
private static Message getPostMessage(Runnable r) { Message m = Message.obtain(); m.callback = r; return m; }可以看到该方法可以对callback属性进行赋值，也就是说，通过post方法发送消息的话和send一样可以完成处理消息（实际上在post中也是调用send方法），只不过不在handleMessage()中处理消息，而是在handleCallback()中处理消息。该方法的源码会让我们大吃一惊的：
private static void handleCallback(Message message) { message.callback.run(); }直接调用了Runnable对象的run()方法，这样一来就不是创建新线程，而是直接调用。
当然也可以在消息的obtain()中设置callback属性。
post方法和send方法的区别
post方法在内部会调用send方法，并且post方法发送的是带有处理方法的消息，而send方法发送的是不带有处理方法的消息。前者消息在自己携带的方法中处理，后者则只能通过handleMessage()处理
更多相关文章
- Android(安卓)java面试题收集
- 解决IE apk变成zip：Android(安卓)手机应用程序文件下载服务器 配
- Oracle就Java在Android中的使用问题向Google提起诉讼
- Android(安卓)4.3 安全提升，Set-UID-Root 权限提升不再起作用，原先
- 仿MIUI的Toast动画效果实现
- Android核心分析 之一--------分析方法论探讨之设计意图【转】
- Android支持多种设备的方法及资源文件的使用
- Android贪吃蛇的Swing版本
- Android(安卓)widget定时更新及事件处理