Handler源码解析

从接触Android开始就认为Handler是个神奇的东西，后来多次去窥探它的神奇之处，每次都有一些收获，但一直都未记录下来，过段时间又会忘记，今天这里重新梳理一遍Handler原理并记录下来，加深记忆同时方便以后复习。
1、概述

在分析Handler原理时少不了Looper、Message的介绍，它们共同实现Android异步消息处理。

那Handler、Looper、Message是怎样实现不同线程之间的消息处理的呢？

简单的说就是：Handler将Message发送到Looper内部的一个消息队列MessageQueue中，Looper内有个无线循环，不断的在MessageQueue中获取msg，将msg回调给Handler处理，MessageQueue为空时，线程阻塞等待。

2、源码走读

2.1、Handler消息发送

首先从Handler发送消息着手，Handler提供给外部使用的发送消息发送有以下多个：

    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);    }    public final boolean postDelayed(Runnable r, long delayMillis)    {        return sendMessageDelayed(getPostMessage(r), delayMillis);    }    public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }    public final boolean sendEmptyMessage(int what)    {        return sendEmptyMessageDelayed(what, 0);    }    public final boolean sendEmptyMessageDelayed(int what, long delayMillis)    {        Message msg = Message.obtain();        msg.what = what;        return sendMessageDelayed(msg, delayMillis);    }    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis)    {        Message msg = Message.obtain();        msg.what = what;        return sendMessageAtTime(msg, uptimeMillis);    }    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);    }

方法虽然较多，不难发现它们最终都会进入54行的这个sendMessageAtTime(...)方法，该方法56行的mQueue在Hanlder构造方法中获得，这里贴出代码量较少的一个构造方法：

public Handler(Looper looper, Callback callback, boolean async)    {        mLooper = looper;        mQueue = looper.mQueue;        mCallback = callback;        mAsynchronous = async;    }

可以看到mQueue是从looper中获取到的。回到上面的sendMessageAtTime(...)方法，方法在对mQueue判空后，调用了enqueueMessage(...)方法，并将在Looper中获取到的mQueue传入。

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

这个方法很简单，先将Handler绑定在msg的target上（这里其实就是为msg加上一个标记，当消息处理时能够通过这个标记回到之前的Handler内处理），然后将msg加入到Looper内的messageQueue中。

到这里Handler的消息发送过程也就走读完了，消息已经发送到Looper的messageQueue中，接下来就看一下MessageQueue插入message的工作流程。

2.2、MessageQueue如何插入message

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

第2行判断msg是否绑定了handler，若没有直接抛出异常。第5行判断msg是否正在插入处理，若正在处理直接抛出异常。第18行将msg标记为正在插入处理。22行：若当前队列没有消息||当前插入消息为即时消息||插入消息执行时间小于当前准备处理的消息，则将插入消息为优先级最高的消息，插入到队列最前端记录为当前准备处理消息。若22行条件不满足，则在33行循环现有队列，直到36行找到插入位置，在43-44行插入到队列中去。到这里就完成了message插入到MessageQueue的流程。下面接着看持有MessageQueue的Looper的工作流程。

2.3、Looper

Looper最重要的两个方法为prepare()和loop(),这两个方法在Activity创建时就已被调用，所以我们使用中可能并未手动调用。首先看下Looper的prepare()方法：

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

这里sThreadLoacal为ThreadLoacal对象，它用来在当前线程中保存一个Looper对象，第8行先判断sThreadLoacal是否已有looper对象，若有则直接抛出异常，这也就保证了一个线程中只能有一个looper对象。第12行sThreadLoacal未保存looper时，新建一个looper并保存在sThreadLoacal。

Looper的构造方法如下：

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

在构造方法中创建了久违的MessageQueue，由于一个线程中只有一个Looper，所以一个线程中也只有一个MessageQueue。

下面看一下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;        // Make sure the identity of this thread is that of the local process,        // and keep track of what that identity token actually is.        Binder.clearCallingIdentity();        final long ident = Binder.clearCallingIdentity();        for (;;) {            Message msg = queue.next(); // might block            if (msg == null) {                // No message indicates that the message queue is quitting.                return;            }            // This must be in a local variable, in case a UI event sets the logger            final Printer logging = me.mLogging;            if (logging != null) {                logging.println(">>>>> Dispatching to " + msg.target + " " +                        msg.callback + ": " + msg.what);            }            final long traceTag = me.mTraceTag;            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));            }            try {                msg.target.dispatchMessage(msg);            } finally {                if (traceTag != 0) {                    Trace.traceEnd(traceTag);                }            }            if (logging != null) {                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);            }            // Make sure that during the course of dispatching the            // identity of the thread wasn't corrupted.            final long newIdent = Binder.clearCallingIdentity();            if (ident != newIdent) {                Log.wtf(TAG, "Thread identity changed from 0x"                        + Long.toHexString(ident) + " to 0x"                        + Long.toHexString(newIdent) + " while dispatching to "                        + msg.target.getClass().getName() + " "                        + msg.callback + " what=" + msg.what);            }            msg.recycleUnchecked();        }    }

第2行myLooper()方法为从sThreadLoacal中获取looper对象，第3行若获取到的looper为空则直接抛出异常。第6行从looper中拿出messageQueue对象。13行进入进入无线循环。14行从队列中获取一条消息。15行获取到的消息为空时，也就是队列中没有消息时，跳出循环。32行将消息发送给指定的target，这里的target也就是上面绑定在message上的handler。

2.1、Handler消息接收

上面message回到了发送它的Handler的dispatchMessage(msg)：

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

第3行首先判断msg是否添加了callback，若添加了则优先执行hanldleCallback()

private static void handleCallback(Message message) {    message.callback.run();}

即直接执行messge的回调。

若msg未添加callback，则在第6行判断Handler是否添加了callback（handler构造时可添加callback），若Handler添加了callback则将msg在第7行回调给handler的callback。

若handler也未添加callback或第7行回调失败，则执行handlerMessage(msg)方法：

public void handleMessage(Message msg) {    }

而handlerMessage(msg)本身为一个空实现的方法，这时就需要使用者复写该方法，在里面对msg做具体处理了，一般使用时都会根据不同的msg.what来区分不同的消息，如下：

    private Handler mHandler = new Handler()    {        public void handleMessage(android.os.Message msg)        {            switch (msg.what)            {                case value:                    break;                default:                    break;            }        }    };

到这里handler的发送消息的流程就已基本走完了。
3、总结

1、在指定线程创建handler，之后handler收到的消息都会在该线程中；

2、handler在其他线程将消息发送给当前线程的Looper的MessageQueue中去；

3、一个线程只有一个Looper，同时也就只有一个MessageQueue；

4、MessageQueue按msg的时间优先级将msg插入到合理位置；

5、looper无线循环取出msg，并将msg发回msg绑定的handler；