image.png

前言

在看过了网上那么多的Android的异步消息处理机制的文章之后，总是觉得不够系统，要么是copy来copy去的代码，要么是凌乱的结构，让人看的云里雾里的，也可能是没有看懂并转化成自己的东西。官方文档也没有详细的去解释其之间的关系，只有的类注释，然后我们就只能Read the Fucking Source Code ！其实我们只要把官方文档的解释加上源码就能理清这个机制的原理。
PS：在此强调一点就是，去学习android的东西，一定要看官方文档，官方文档才是最原汁原味的，网上的文章都是别人消化过的，不是你的理解，所以一定要去官网都挨个撸一遍，做到心中有数，这样以后查起文档就有的放矢了。
链接：GoogleAndroid 开发者官方网站

1. Android的线程

在说异步消息处理机制之前，一定要先去看一下这篇文章《Android的单线程》，只有看了这篇文章你才知道为什么会有异步消息处理机制。

2. 异步消息处理机制类

首先我们要了了解一下这几个类：

Handler
Looper
Message
MessageQueue

在介绍之前，我想大家最一开始使用的都是从Handler，即使没看过源码，也知道大概的使用方式了，所以使用方法这里我不做赘述，下面一一介绍：

Handler

我按照官方文档英文翻译一下，如果大家英语好的话也可以去原文地址去看：

一个Handler允许你发送或处理Message和Runnable对象到线程的消息队。每一个Handler实例都和一个单一的线程相关联，就是消息队列所在的线程。当你创建一个新的Handler对象，从那时起，它就会绑定到线程所创建的消息队列中，它会发送消息或者Runnable接口到消息队列，当他们从消息队列出来之后便依次执行。

然后Handler有2种主要的使用：

执行Message对象和在未来特定时刻执行Runnable接口；

sendMessage(Message)

sendEmptyMessage(int)

sendEmptyMessageDelayed(int,long)

sendEmptyMessageAtTime(int)

sendMessageDelayed(int,long)

sendMessageAtTime(int,long)

sendMessageAtFrontOfQueue(Message)

在一个不同的线程加入一个动作使之执行而不是你自己去实现。

post(Runnable)

postAtTime(Runnable,long)

postAtTime(Runnable,object,long)

postDelayed(Runnable,long)

postAtFrontOfQueue(Runnable)

然后我们在Handler.handleMessage Callback中处理回传回来的消息。

Looper

Looper这个类大家肯定也很熟悉，还记得你第一次使用Looper，抛出RuntimeException :"Only one Looper may be created per thread"吗？没错就是你在某一个已经绑定了一个Looper对象的线程中调用Looper.prepare()时产生的。下面看一段典型的代码：

class LooperThread extends Thread {
  public Handler mHandler;

  public void run() {
      Looper.prepare();

      mHandler = new Handler() {
          public void handleMessage(Message msg) {
              // process incoming messages here
          }
      };

      Looper.loop();
  }}

Looper的作用其实就是一个消息循环器，它不停的从消息池中取出消息，然后在当前线程中分发消息。但是使用的时候一定要注意，要绑定到一个线程，先调用prepare再调用loop。

那么Looper.prepare()究竟做了什么，我们看源码：

/** Initialize the current thread as a looper.
  * This gives you a chance to create handlers that then reference
  * this looper, before actually starting the loop. Be sure to call
  * {@link #loop()} after calling this method, and end it by calling
  * {@link #quit()}.
  */
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));
}

首先我们看第一个函数prepare()的注释：

注释：Initialize the current thread as a looper.This gives you a chance to create handlers that then reference
this looper, before actually starting the loop. Be sure to call loop after calling this method, and end it by
calling quit

翻译：初始化当前的线程作为一个looper对象。在真正的开始消息循环之前，给你机会去创建一个或多个handler来指向到这个looper对象。但是要确保当调用完这个方法之后一定要调用Loop方法，然后调用quit来结束它。

然后我们再看第二个函数的具体实现，我们看到了有一个类ThreadLocal貌似我们从未见过，也没有在实际项目当中使用过，但是如果有的同学如果看过《JAVA并发编程实战》第三章节中的对象的共享，应该会有印象。不过没关系，我们还是用过类注释来了解它到底是用来干嘛的：

注释：Implements a thread-local storage, that is, a variable for which each thread has its own value. All threads share the same ThreadLocal object, but each sees a different value when accessing it, and changes made by one thread do not affect the other threads. The implementation supports null values.

翻译：实现了一个线程局部存储，就是每一个线程都有自己对应的值。所有的线程共享ThreadLocal对象，但是当访问的时候，每一个线程会看到不同的值。一个线程的改变不会影响其他线程。这种实现还支持存储null。

然后我们在看ThreadLocal所包含的方法：

image.png

发现和WeakReference的结构很像！然后我们继续看下源码：

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

定位到ThreadLocalMap,在看下源码：

static class ThreadLocalMap {
    /**
     * The entries in this hash map extend WeakReference, using
     * its main ref field as the key (which is always a
     * ThreadLocal object).  Note that null keys (i.e. entry.get()
     * == null) mean that the key is no longer referenced, so the
     * entry can be expunged from table.  Such entries are referred to
     * as "stale entries" in the code that follows.
     */
    static class Entry extends WeakReference<ThreadLocal> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal k, Object v) {
            super(k);
            value = v;
        }
       ...下面代码省略
    }}

看到没，原来是ThreadLocal内部使用弱引用WeakReference来存储当前线程对象，以ThreadLocal为Key，value为Object。另外值得注意的一点是，上面的Entry继承自WeakReference，这样的好处就是能够及时回收Looper中创建的ThreadLocal对象。

接下来是Looper.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) {
            // No message indicates that the message queue is quitting.
            return;
        }
       //...中间省略代码
        try {
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
       //...中间省略代码
        msg.recycleUnchecked();
    }
}

首先第一行，Looper.myLooper():

 public static Looper myLooper() {
    return sThreadLocal.get();
}

也就是从sThreadLocal静态对象中取出在调用Looper.prepare函数时存放的Looper对象。取出之后，调用Looper中的已经初始化好的对象MessageQueue取出消息池中的消息Message进行操作，取出之后就要将消息进行分发了，此时调用Message.target.dispatchMessage(msg)，追溯到源码：

public final class Message implements Parcelable {
       Handler target;
}

原来Message内部持有一个Handler对象，那么这个对象是在什么时候进行赋值的呢，继续看Handler源码：

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);
}}

msg.target = this 就是这句！
我们搞明白了Handler在什么时候传递给Message之后，我们就明白消息是怎么回调的了，下面看dispatchMessage(Message msg)函数的实现：

 public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

这里有if else判断是如果回调函数不为空，则处理回调函数，否则处理消息，很简单，这里其实再次强调了Handler两种主要用法，sendMessage & post Runnable接口。

Message & MessageQueue

由于MessageQueue实际就是操作的Message对象，所以把他们结合在一起来说。刚才讲到Handler有sendMessage(message)功能，看下源码，原来是Handler把Message对象发送到MessageQueue中，下面看个流程图：

image.png

最终定位到了下面的代码：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

queue.enqueueMessage(msg, uptimeMillis)，继续看MessageQueue里面的这个函数

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.");
    }
   
   //此处省略若干代码...
    Message p = mMessages;
    boolean needWake;
    synchronized (this) {
       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;
    }
        if (needWake) {
            nativeWake(mPtr);
        }
    return true;
}

我们不需完全看懂完整的代码，我们只看核心的部分，首先for循环部分是在不停的取出消息，然后取出消息调用了nativeWake函数，查看源码后发现：

 private native static void nativeWake(long ptr);

是本地的实现，我们也不需要care（当然如果你有兴趣可以去查看源码），只需要知道这个函数是唤醒消息队列再次处理消息即可，而整个的消息的循环是采用Sleep-Wakeup 机制。也就是说当队列中没有消息的时候，并不会不停的去取消息，而是进行休眠，休眠的意思大家想想自己的电脑就明白了，当再次点击电源键时，能够立刻唤醒进行工作，此处消息队列的处理也是一样，当消息队列中有消息的时候调用nativeWake来唤醒Looper线程。

另外值得注意的是，Message内部是采用消息池的机制，这样在获取的消息的时候回优先从消息池中取出可用的消息对象，如果没有再进行初始化，这样的好处就避免了不必要的内存开销。另外，Message类也提供了上述代码静态工厂方法Message.obtain()。

/**
 * Return a new Message instance from the global pool. Allows us to
 * avoid allocating new objects in many cases.
 */
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.obtain()来构造Message对象。

3. 异步消息处理机制

说到这里，可以用一张图来总结整个的流程：

image.png

经过以上的几个关键的类的介绍，原理也大概明白了，其中间过程发生了什么，在什么时候发生，大家可以在源码中仔细查看。最后总结一下：

Android应用程序的消息处理机制由消息循环、消息发送和消息处理三个部分组成的；
Android应用程序的消息处理内部是使用ThreadLocal来将一个Looper对象绑定到一个线程上；
Android应用程序的主线程进入空闲等待状态时不处理消息，来了消息之后利用本地nativeWake函数来进行唤醒；
Android应用程序的消息采用消息池机制来存取消息。