Android消息机制

Android的消息机制主要是指Handler的运行方式。
对于Android开发者而言，Handler并不陌生，它常常被用来向主线程post消息，更新UI等操作。日常开发中只需和Handler类交互即可，然而，稍微深入了解Handler运行机制可以让开发者更加熟悉Android系统消息机制，做到运用自如。
Handler的运行需要MessageQueue和Looper的支撑。MessageQueue保存消息，提供消息队列的实现；Looper实现线程循环处理消息和分发；其他线程通过Handler对象可以向Looper线程发送消息（该消息最终由创建Handler的线程负责处理），Handler MessageQueue和Looper三者工作关系大致如下：

1.MessageQueue

该类是消息队列实现类，消息实体由Message类实现。在MessageQueue类中维护着一个Message链表（虽然取名为队列，其实现是单向链表），其核心操作是向消息队列添加消息以及获取消息，分别对应于方法enqueueMessage()和next()。
enqueueMessage方法原型如下：

 boolean enqueueMessage(Message msg, long when) {
     //单向链表同步插入
 }

next方法即是从链表中获取一条消息并返回给调用者，同时将该条消息从链表中删除；
MessageQueue的逻辑并不复杂，需要了解的基本操作就是插入和获取，很清晰。

2.Looper

Looper类的核心职能是循环读取消息队列中的消息，并分发出去。

Looper构建
Looper类核心变量：

 // sThreadLocal.get() will return null unless you've called prepare().
 static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

 final MessageQueue mQueue;
 final Thread mThread;

其中sThreadLocal 是线程私有变量，为每个创建Looper的线程保存其创建的Looper对象；
mQueue是消息队列；
mThread是创建Looper的线程；
在Looper对象的构造方法中会初始化消息队列：

   private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
   }

从上面代码片段可知Looper的构造函数是私有的，因此，Looper对象的构建并不是手动创建的。从源码可以得知，通过静态方法 prepare() 可以为当前线程创建Looper对象，同时在Looper的创建中又会创建消息队列。因此，在使用时只需在当前线程内调用Looper.prepare()，即可完成Looper对象和消息队列的构建，示例如下：

new Thread("#SubThread"){
    @Override
    public void run() {
        Looper.prepare();
    }
}.start();

这样即可给线程”#SubThread”构建Looper和MessageQueue（当然仅仅是给Handler的使用创建必须的消息队列和循环机制，仅这样不能构建消息机制）。Looper还为主线程单独提供prepareMainLooper()方法(内部调用prepare方法)，并保存主线程的Looper对象且提供获取主线程Looper的方法getMainLooper()。

开启消息循环
构建Looper之后必须调用loop()方法，手动开启消息循环。为线程构建消息队列的完整步骤如下：

new Thread("#SubThread"){
    @Override
    public void run() {
        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();
    }
}.start();

分析源码可知，loop方法是一个死循环，不断地从消息队列中获取消息（如果队列暂时没有消息，则阻塞直至有线程向消息队列添加消息为止），并将消息分发。
至此 线程”#SubThread”已构建消息队列，并开启消息循环。其它线程通过handler即可向线程”#SubThread”发送消息。

3.Handler

Handler类是消息机制中最常被开发者使用。常见的情况是在UI线程（主线程）中使用Handler，子线程通过Handler对象完成更新UI等操作，而无须接触MessageQueue和Looper。究其原因是主线程在启动过程中已完成MessageQueue和Looper的创建，以下是ActivityThread类main方法的代码片段：

 public static void main(String[] args) {
       //省略多行代码
        Looper.prepareMainLooper();

        //省略多行代码

        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

可见，在主线程启动过程中，已经构建消息队列并开启消息循环，因此，在主线程中，我们可以方便的使用Handler，而无须关心其对应得Looper和MessageQueue。但是，为了更好理解消息机制，了解Handler是如何与Looper和MessageQueue协同工作还是有必要的。

Handler的创建
如上方式Handler handler = new Handler();创建Handler对象最终会调用下边的构造方法：

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

代码逻辑很清晰，如果是在没有构建Looper的线程内调用此构造方法会抛出运行时异常，并提示“不可以在未调用Looper.prepare()方法的线程内创建Handler对象”；创建过程中handler会保存Looper中消息队列的引用，便于后续的消息添加。

通过Handler发送消息
通过调用Handler类提供的sendMessage系列方法可以发送消息，不同类型的sendMessage方法发送的消息内容设置稍有不同，以一条空消息为例，如下调用即可：

handler.sendEmptyMessage(MSG_TEST);

方法经过几次传递最终会调用enqueueMessage方法，该方法是Handler发送消息的实际操作部分，代码如下：

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

该方法其实也不是真正干活的，它调用MessageQueue的enqueueMessage方法向消息队列中添加一条消息。
因此通过Handler发送消息的逻辑最终归结为向MessageQueue消息链表内添加一条消息。

发送的消息如何传递至handleMessage()方法
一般在构建Handler对象时，我们会重写handleMessage方法，在该方法内处理各个不同类别的信息，典型逻辑如下：

 Handler handler = new Handler(){
      @Override
      public void handleMessage(Message msg) {
          switch (msg.what){
             case MSG_ONE:
                 handleMsgOne();
                 break;
             case MSG_TWO:
                 handleMsgTwo();
                 break;
             default:
                 break;
          }
     }
};

那么经由handler 调用sendMessage的消息是如何被传递至handleMessage方法内的呢？
上一段，我们讲到sendMessage最终是在消息队列中添加一条消息记录，而是谁在不断读取并分发消息队列中的消息呢？没错就是Looper。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;
            }

            //省略多行

            msg.target.dispatchMessage(msg);

            //省略多行

            msg.recycleUnchecked();
        }
    }

loop方法的逻辑也比较清晰：调用MessageQueue的next()方法获取一条消息，调用消息对象msg的target字段的dispatchMessage方法分发消息；
那么，分发消息应该就是由，这个msg所对应的target来处理了。
Message类中target字段定义/*package*/ Handler target;
可知，target是一个Handler对象，而在sendMessage的过程中的最终函数enqueueMessage（代码见上文）中有关键的一句：

 msg.target = this;

即将msg的target对象指向了发送msg的handler，因此，dispatchMessage最终还是由发送msg的Handler对象处理。
Handler的dispatchMessage方法如下：

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

终于，在这里调用了hanleMessage()方法，把消息处理的最终实体回调给Handler的定义者（hanleMessage()默认为空实现）。

看到这里，相信读者对Android的消息机制有一定的了解了。
那么有同学可能会问了，Handler内先通过sendMessage添加消息，再经由Looper回调handleMessage()方法，兜一圈不累吗？
Android系统的设计者们估计会说，累但很有必要。细心的读者会发现，调用sendMessage 和回调handleMessage的线程是不同的。sendMessage可以在任何子线程内通过handler对象发送，而回调handleMessage的线程是当初创建Handler ,Looper和MessageQueue的线程。这也就是为什么我们常常在主线程内创建Handler对象，重写相应的handleMessage()逻辑并且可以在此更新UI，而各子线程内一般只能通过这个Handler对象发送消息。
Handler，MessageQueue和Looper三者的配合构成了Android系统的消息机制，提供了一种线程通信实现方式，它在Android FrameWork 可以经常看到，使用简单（尤其是也主要是在UI线程和子线程通信的情况中），希望大家通过这篇文章可以对它有更好的了解。