Android Handler源码解析

---

版权声明：本文为博主原创文章，欢迎大家转载！

转载请标明出处： http://blog.csdn.net/guiying712/article/details/53412281，本文出自:【张华洋的博客】

---

Handler允许我们发送和处理Message ， 还可以将Runnable对象关联到线程的MessageQueue；每个Handler实例都会与一个线程以及线程的消息队列相关联。当我们创建一个新的Handler后，这个Handler就会与它创建所在的线程和线程的消息队列绑定，它将Message 传送到消息队列，并执行从MessageQueue中出列的消息。

Handler主要有两个用途：

(1) 调度 messages和runnables，以便在未来的某个时间点执行；

(2) 将一个action发送到另一个线程排队等待执行，这种用法大家应该使用的最多，就是在子线程通知主线程更新 UI。

Handler主要有以下两种使用方式：

class SnackbarManager {

    ...
    private final Handler mHandler;

    private SnackbarManager() {
        ...
        mHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(Message message) {
                switch (message.what) {
                    case MSG_TIMEOUT:
                        handleTimeout((SnackbarRecord) message.obj);
                        return true;
                }
                return false;
            }
        });
    }

以及内部类的方式：

class AlarmManagerService extends SystemService {

    ...
    final AlarmHandler mHandler = new AlarmHandler();

    private class AlarmHandler extends Handler {
        public static final int ALARM_EVENT = 1;

        public void handleMessage(Message msg) {
            switch (msg.what) {
                case ALARM_EVENT: {
                    ...
                    break;    
                default:
                    // nope, just ignore it
                    break;
            }
        }
    }

在文章的开始我们已经讲过，Handler主要用来发送和处理Message，在上面的代码中我们已经有了处理Message的逻辑，那么消息是怎么被传送到Handler中处理消息的地方呢？

因为Handler即可以处理Message又可以处理Runnable，所以消息调度主要有如下几个方法：

{@link #post},
{@link #postAtTime(Runnable, long)},
{@link #postDelayed}
{@link #sendEmptyMessage},
{@link #sendMessageAtTime},
{@link #sendMessageDelayed} .

其中带 post 的方法都是用来发送Runnable，而带 send 方法则是用来发送Message的，实质上 post 方法内部也是调用 send 方法来调度Runnable的；我们来看下面的方法：

public final boolean post(Runnable r){
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

 public final boolean postAtTime(Runnable r, long uptimeMillis){
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }

 public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    }

我们可以看到每个post方法中都调用了send方法将Runnable添加到消息队列中，getPostMessage就是用来将postf方法中的入参 Runnable 转换成 Message 类型 的方法；

 private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

我们可以看到 Message 中持有的变量 callback 引用就是一个Runnable对象。

我们再看下Handler的 dispatchMessage 方法，这个方法是用来分发消息的：

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

在getPostMessage方法中，我们post 的 Runnable对象被赋值到 Message 的 callback 引用中了，因此处理这种消息是通过handleCallback(msg)来处理的；而 send 的 Message对象 是通过 handleMessage(msg) 来处理的。

不管是 post 方法还是 send 方法，最终都会调用 enqueueMessage() 方法，将Message添加到消息队列中。

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

在调用 enqueueMessage方法时，会传入 Message 和它要入队的MessageQueue ，在方法内部，入参Message 会将当前的 Handler对象赋值到自己的 变量 target ，这样每一个Message都持有了发送Message的Handler对象。然后在通过MessageQueue 的 enqueueMessage方法，将Message送入这个MessageQueue 中排队。

我们先不着急进入MessageQueue 的enqueueMessage方法中。首先我们需要考虑下Handler中的MessageQueue 是从哪来的？不管是post 和 send 方法中， 我们都没有传入过MessageQueue 。

通过查看代码我们可以发现每个send方法中都有 MessageQueue queue = mQueue，那么mQueue又是在哪里赋值的呢？

在Handler类中，主要有这么几个成员变量：

    final Looper mLooper;
    final MessageQueue mQueue;
    final Callback mCallback;
    final boolean mAsynchronous;
    IMessenger mMessenger;

其中MessageQueue 就是消息队列，Callback接口使用来处理消息的，IMessenger 是用来跨进程通信的，mAsynchronous如果为true，意味着message将不再受Looper的同步机制限制，接下来Handler机制中非常重要的角色Looper ，而我们的MessageQueue 就是通过 looper.mQueue 获取到的。

Looper是用于在线程中运行消息循环的类，默认情况下，线程中没有与之关联的 消息循环(Looper)。Handler中主要有两种方式获得Looper ，一种是通过 Looper.myLooper() 获得Looper 对象，还有一种方式就是在 创建Handler对象是传入一个Looper对象。但是不管哪种方式，都是通过 Looper.prepare() 来创建Looper 对象的，一旦创建后，这个消息循环就会运行在它被创建的那个线程中，然后使用 loop() 来处理消息，直到这个消息循环停止；

在prepare方法中，我们可以看到Looper类中使用了 ThreadLocal来保存Looper对象。

public final class Looper {

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


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

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


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

    public static MessageQueue myQueue() {
        return myLooper().mQueue;
    }

在prepare方法中，检查当前线程中有没有Looper对象，如果有就抛出异常（每个线程中只能创建一个循环），如果没有，就 new 一个Looper对象，而MessageQueue对象就是在Looper构造函数中创建的，Handler中持有的MessageQueue对象也正是Looper中的MessageQueue对象。创建的Looper对象被保存到了ThreadLocal中，ThreadLocal在保存Looper时，会先获取当前Thread线程对象，然后通过Thread对象 获取到 Thread对象持有的ThreadLocalMap，并以当前ThreadLocal 对象做为key，以Looper对象作为 value 保存到ThreadLocalMap中。因此我们就可以通过 ThreadLocal的get() 方法获取到保存到 当前线程的ThreadLocalMap 中的 Looper对象。

接下来我们需要重点分析下Looper类的 loop() 方法。

   /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the 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);
                ...
            } 
            ...

            msg.recycleUnchecked();//这个消息的使命已经完成，回收这个消息以便通过 obtain() 再次使用；
        }
    }

我在 loop() 方法中只保留了关键信息，我们可以看到当调用了 loop() 方法后，首先需要获取到当前线程中保存的 Looper对象，如果这个Looper对象为空就会抛出异常（没有在当前线程中调用Looper.prepare() 创建 Looper），然后获取到Looper持有的 MessageQueue ，之后便进入了一个无限循环中，每次进入循环都取出一条消息，如果没有消息则阻塞。在前面我们已经分析过，在 Handler 的 enqueueMessage() 方法中有一行代码 msg.target = this，将Handler 赋值到 Message的target 变量中，因此我们就可以通过 msg.target 获取到发送消息的Handler，然后在调用这个Handler的dispatchMessage()方法，将消息分发出去，由于这个方法我们已经在前面分析过，就不再深入了。

另外我们是可以通过 调用 Looper的 quit()方法 退出消息循环的，当然 quit()方法中实际上是 通过 Looper持有的MessageQueue对象的 quit() 方法退出的；

quit 退出机制 有两种，分为 普通退出和安全退出。他们的区别在于，普通退出 会导致 loop（循环） 直接终止，不会再处理消息队列中的任何消息，这时候你调用 Handler#sendMessage(Message)方法会直接返回 false，使用这个方法会造成一些消息不会被 传送到 Handler 中 处理 。而安全退出则 会等到消息队列中的所有消息都已经被 交付到 Handler处理后才会 终止 loop 循环。

讲到这里我们基本可以勾勒出整个Handler消息机制的架构了：

不过我们现在还有一个重要的地方没有分析，那就是MessageQueue。我们在前面讲到了 通过MessageQueue 的 enqueueMessage方法，将Message送入这个MessageQueue 中排队，那么现在我们就深入到 MessageQueue 的 enqueueMessage() 方法中去。

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

        synchronized (this) {
            if (mQuitting) {
                IllegalStateException e = new IllegalStateException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w(TAG, e.getMessage(), e);
                msg.recycle();
                return false;
            }

            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                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;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

进入enqueueMessage()方法中，首先判断Message持有的Handler是不是为空，如果为空就抛出异常（消息必须有一个目标Handler-用来分发和处理消息）。

然后判断这个消息是否在使用中 isInUse（消息从 enqueue 到 被回收这个阶段就是 FLAG_IN_USE），如果已经在使用中了，也会抛出异常（这个消息已经在使用中）。

接着判断这个MessageQueue 是否正在退出中，如果 MessageQueue 正在退出中，就回收这个Message，并返回 false。

如果前面判断都通过后，就将这个Message标记为 FLAG_IN_USE。

MessageQueue 类中的 成员变量 mMessages 是 loop() 方法中当前拿到的Message对象， enqueueMessage()方法中需要判断 当前 loop循环 是 否在阻塞中，如果处于阻塞中就需要唤醒这个loop 循环 处理 新加入的消息。另外 消息队列 是一个单链表，所以每个消息都需要记录 next位置的 消息。

到这里，整个Handler源码就算是分析完了，下篇将会分析在Looper类中使用到的 ThreadLocal 类。