理解Handler消息机制

Handler并不是专门用于更新UI，它只是常被开发者用来更新UI。

Android的消息机制主要指Handler的运行机制，底层需要MessageQueue和Looper的支撑。MessageQueue是采用单链表的数据结构来存储消息列表的，Looper为消息循环。由于MessageQueue是一个消息的存储单元，不能处理信息，Looper就填补了这一功能，Looper会以无限循环的方式去查找是否有新消息，有就处理，没有就等待。Looper还有一个ThreadLocal，可以在每个线程中存储数据。通过ThreadLocal可以获取每个线程的Looper，一般线程默认是没有Looper，除了UI线程，所以就必须创建Looper。

一、Android消息机制概述

Handler的主要功能是将一个任务切换到某个指定的线程中去操作，这是因为Android规定UI操作只能在主线程，不然就会抛出异常，原因是因为ViewRootImpl对UI操作做了验证，通过ViewRootImpl的checkThread方法来完成。

系统提供Handler的主要原因是为了解决子线程中无法访问到UI的矛盾。

这是因为Android的UI控件不是线程安全的，如果多线程访问会导致UI处于不可预期状态，如果加上锁机制，会有两个问题：
- 加上锁会导致让UI访问的逻辑变得复杂
- 降低UI的访问效率

一般创建Handler的时候需要有Looper，不然会出现异常。

Handler创建以后，会同内部的Looper以及MessageQueue一起协同工作，然后Handler的post方法将一个Runanble投递到Handler内部的Looper中去处理，其实post也是通过send方法来完成的，当调用send方法时，会调用MessageQueue的enqueueMessage方法将消息放到消息队列中，然后Looper发现有新的消息来时，则会处理这个消息，最后消息中的Runnable或者Handler的handleMessage方法会被调用。注意Looper是运行在创建Handler所在的线程中的，这样一来Handler中的业务逻辑就被切换到创建Handler所在的线程中去执行。

---

二、Android的消息机制分析

1.ThreadLocal的工作原理

ThreadLocalThreadLocal是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储的数据，对于其它线程来说无法获取到数据。ThreadLocal另一个使用场景是复杂逻辑下的对象传递，比如监听器的传递，有些时候一个线程中的任务过于复杂，这可能表现为函数调用栈比较深以及代码入口的多样性，在这种情况下，我们又需要监听器能够贯穿整个线程的执行过程，这个时候可以怎么做呢？其实就可以采用ThreadLocal，采用ThreadLocal可以让监听器作为线程内的全局对象而存在，在线程内部只要通过get方法就可以获取到监听器。

介绍了那么多ThreadLocal的知识，可能还是有点抽象，下面通过实际的例子为大家演示ThreadLocal的真正含义。首先定义一个ThreadLocal对象，这里选择Boolean类型的，如下所示：

private ThreadLocal<Boolean>mBooleanThreadLocal = new ThreadLocal<Boolean>();

然后分别在主线程、子线程1和子线程2中设置和访问它的值，代码如下所示：

mBooleanThreadLocal.set(true);
Log.d(TAG, "[Thread#main]mBooleanThreadLocal=" + mBooleanThreadLocal.get());

new Thread("Thread#1") {
    @Override
    public void run() {
        mBooleanThreadLocal.set(false);
        Log.d(TAG, "[Thread#1]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
    };
}.start();

new Thread("Thread#2") {
    @Override
    public void run() {
        Log.d(TAG, "[Thread#2]mBooleanThreadLocal=" + mBooleanThreadLocal.get());
    };
}.start();

在上面的代码中，在主线程中设置mBooleanThreadLocal的值为true，在子线程1中设置mBooleanThreadLocal的值为false，在子线程2中不设置mBooleanThreadLocal的值，然后分别在3个线程中通过get方法去mBooleanThreadLocal的值，根据前面对ThreadLocal的描述，这个时候，主线程中应该是true，子线程1中应该是false，而子线程2中由于没有设置值，所以应该是null，安装并运行程序，日志如下所示：

D/TestActivity(8676):[Thread#main]mBooleanThreadLocal=true
D/TestActivity(8676):[Thread#1]mBooleanThreadLocal=false
D/TestActivity(8676):[Thread#2]mBooleanThreadLocal=null

从上面日志可以看出，虽然在不同线程中访问的是同一个ThreadLocal对象，但是它们通过ThreadLocal来获取到的值却是不一样的，这就是ThreadLocal的奇妙之处。结合这这个例子然后再看一遍前面对ThreadLocal的两个使用场景的理论分析，大家应该就能比较好地理解ThreadLocal的使用方法了。ThreadLocal之所以有这么奇妙的效果，是因为不同线程访问同一个ThreadLocal的get方法，ThreadLocal内部会从各自的线程中取出一个数组，然后再从数组中根据当前ThreadLocal的索引去查找出对应的value值，很显然，不同线程中的数组是不同的，这就是为什么通过ThreadLocal可以在不同的线程中维护一套数据的副本并且彼此互不干扰。

ThreadLocal是一个泛型类，它的定义为public class ThreadLocal，只要弄清楚ThreadLocal的get和set方法就可以明白它的工作原理。
首先看ThreadLocal的set方法，如下所示：

public void set(T value) {
    Thread currentThread = Thread.currentThread();
    Values values = values(currentThread);
    if (values == null) {
        values = initializeValues(currentThread);
    }
    values.put(this, value);
}

在上面的set方法中，首先会通过values方法来获取当前线程中的ThreadLocal数据，如果获取呢？其实获取的方式也是很简单的，在Thread类的内容有一个成员专门用于存储线程的ThreadLocal的数据，如下所示：ThreadLocal.Values localValues，因此获取当前线程的ThreadLocal数据就变得异常简单了。如果localValues的值为null，那么就需要对其进行初始化，初始化后再将ThreadLocal的值进行存储。下面看下ThreadLocal的值到底是怎么localValues中进行存储的。在localValues内部有一个数组：private Object[] table，ThreadLocal的值就是存在在这个table数组中，下面看下localValues是如何使用put方法将ThreadLocal的值存储到table数组中的，如下所示：

void put(ThreadLocal<?> key, Object value) {
    cleanUp();

    // Keep track of first tombstone. That's where we want to go back
    // and add an entry if necessary.
    int firstTombstone = -1;

    for (int index = key.hash & mask;; index = next(index)) {
        Object k = table[index];

        if (k == key.reference) {
            // Replace existing entry.
            table[index + 1] = value;
            return;
        }

        if (k == null) {
            if (firstTombstone == -1) {
                // Fill in null slot.
                table[index] = key.reference;
                table[index + 1] = value;
                size++;
                return;
            }

            // Go back and replace first tombstone.
            table[firstTombstone] = key.reference;
            table[firstTombstone + 1] = value;
            tombstones--;
            size++;
            return;
        }

        // Remember first tombstone.
        if (firstTombstone == -1 && k == TOMBSTONE) {
            firstTombstone = index;
        }
    }
}

面的代码实现数据的存储过程，这里不去分析它的具体算法，但是我们可以得出一个存储规则，那就是ThreadLocal的值在table数组中的存储位置总是为ThreadLocal的reference字段所标识的对象的下一个位置，比如ThreadLocal的reference对象在table数组的索引为index，那么ThreadLocal的值在table数组中的索引就是index+1。最终ThreadLocal的值将会被存储在table数组中：table[index + 1] = value。

上面分析了ThreadLocal的set方法，这里分析下它的get方法，如下所示：

public T get() {
    // Optimized for the fast path.
    Thread currentThread = Thread.currentThread();
    Values values = values(currentThread);
    if (values != null) {
        Object[] table = values.table;
        int index = hash & values.mask;
        if (this.reference == table[index]) {
            return (T) table[index + 1];
        }
    } else {
        values = initializeValues(currentThread);
    }

    return (T) values.getAfterMiss(this);
}

可以发现，ThreadLocal的get方法的逻辑也比较清晰，它同样是取出当前线程的localValues对象，如果这个对象为null那么就返回初始值，初始值由ThreadLocal的initialValue方法来描述，默认情况下为null，当然也可以重写这个方法，它的默认实现如下所示：

/**
 * Provides the initial value of this variable for the current thread.
 * The default implementation returns {@code null}.
 *
 * @return the initial value of the variable.
 */
protected T initialValue() {
    return null;
}

从ThreadLocal的set和get方法可以看出，它们所操作的对象都是当前线程的localValues对象的table数组，因此在不同线程中访问同一个ThreadLocal的set和get方法，它们对ThreadLocal所做的读写操作仅限于各自线程的内部，这就是为什么ThreadLocal可以在多个线程中互不干扰地存储和修改数据，理解ThreadLocal的实现方式有助于理解Looper的工作原理。

2.消息队列的工作原理

MessageQueue主要包含两个操作：插入和读取，插入和读取分为enqueueMessage和next，其中enqueueMessage是往消息队列中插入一条消息，next是从消息队列中去出一条消息并从消息队列中移除，MessageQueue实际上是使用单链表来实现的。

boolean enqueueMessage(Message msg, long when) {
        ...
        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;

}

它主要是实现单链表的插入操作。

Message next() {
        ....
        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }

            nativePollOnce(ptr, nextPollTimeoutMillis);

            synchronized (this) {
                // Try to retrieve the next message.  Return if found.
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null && msg.target == null) {
                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // Next message is not ready.  Set a timeout to wake up when it is ready.
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // Got a message.
                        mBlocked = false;
                        if (prevMsg != null) {
                            prevMsg.next = msg.next;
                        } else {
                            mMessages = msg.next;
                        }
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        msg.markInUse();
                        return msg;
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
            }
        }

}

next是一个无限循环的方法，如果没有消息，则一直阻塞，如果有消息则继续运行。

3.Looper的工作原理

Looper在Android的消息机制中就是用来进行消息循环的。它会不停地循环，去MessageQueue中查看是否有新消息，如果有消息就立刻处理该消息，否则就一直等待。

首线来看下Looper的构造方法：

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

通过Looper.prepare()即可为当前线程创建一个Looper，接着通过Looper.loop()来开启消息循环：

new Thread("Thread 2"){
    public void run(){
        Looper.prepare();
        Handler handler = new Handler();
        Looper.loop();
    }
}

Looper中除了prepare方法外，还提供了prepareMainLooper方法，这个方法主要是给主线程创建Looper使用的，即是属于ActivityThread的Looper，其本质也是通过prepare来实现的，同时Looper也提供一个getMainLooper方法，通过它可以在任何地方获取ActivityThread的Looper。Looper也是可以退出的，它提供了quit和quitSafely方法来退出，二者的区别是：quit直接退出Looper，quitSafely只是设置一个退出标志，等消息队列中的消息处理完毕，就会退出Looper，这时候Handler的send方法返回false。如果在子线程中手动创建了Looper，要记得退出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;

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

Looper的loop方法也很好理解，loop是一个死循环的方法，唯一跳出死循环的方式是MessageQueue的next方法返回null。当Looper的quit方法被执行的时候，Looper会调用MessageQueue的quit或者quitSafely方法来通知消息队列退出，当被标记退出，消息队列就会返回null。loop的阻塞是因为MessageQueue的next方法阻塞造成的。如果MessageQueue的next方法返回新消息了，那就会调用msg.target.dispatchMessage(msg)来处理，其中msg.target是Handler对象，dispatchMessage虽然是通过Handler调用的，但是是在创建Handler时所使用的Looper中执行的，也就是在当前Looper中或者线程中执行的，这样就可以实现线程的切换。

4. Hanler的工作原理

Handler的工作主要包含消息的发送和接受过程。消息的发送可以通过post或者send的一系列方法来实现，如下所示：

    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

    /**
     * Sends a Message containing only the what value.
     *  
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */
    public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }

    /**
     * Sends a Message containing only the what value, to be delivered
     * after the specified amount of time elapses.
     * @see #sendMessageDelayed(android.os.Message, long) 
     * 
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */
    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

    /**
     * Sends a Message containing only the what value, to be delivered 
     * at a specific time.
     * @see #sendMessageAtTime(android.os.Message, long)
     *  
     * @return Returns true if the message was successfully placed in to the 
     *         message queue.  Returns false on failure, usually because the
     *         looper processing the message queue is exiting.
     */

    public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageAtTime(msg, uptimeMillis);
    }

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

Handler的发送消息就是向MessageQueue队列插入一条消息，然后MessageQueue就会调用next方法返回这条消息给Looper，Looper会开始交由Handler处理，即Handler的dispatchMessage方法会被调用，dispatchMessage的实现如下：

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

Handler的消息处理过程如下：

• 首先先检查Message的callback是否为空，不为空就通过handleCallback来处理，Message的callback是一个Runnable对象，实际上就是Handler的post方法所传递的Runnable参数，handlerCallback的逻辑如下：

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

• 其次检查mCallback是否为null，不为null就调用mCallback的handleMessage方法来处理，Callback是个接口，定义如下：

    public interface Callback {
        public boolean handleMessage(Message msg);
    }

• 通过Callback可以采用如下方法创建Handler handler = new Handler(callable)。在日常开发中，创建Handler最常见的方式是派生一个Handler的子类并且重写它的handleMessage方法，另外一种是传入一个Callback，并实现callback的handleMessage方法。

• 最后调用Handler的handleMessage方法来处理消息。

处理过程的流程图：

Handler还有一个特殊的构造方法，通过一个特定的Looper来构造Handler，实现一些特殊的功能。

---

三、主线程的消息循环

Android的主线程是ActivityThread，主线程的方法入口是mian方法，main方法通过Looper.prepareMainLooper()来创建主线程的Looper和MessageQueue，并通过Looper.loop()来启动循环。主线程的消息循环开始后，需要一个Handler来进行处理和发送，这个就是ActivityThread.H,内部有一组消息类型。ActivityThread通过ApplicationThread和AMS进行通信，AMS一进程间通信完成ActivityThread的请求后回调ApplicationThread的Binder方法，然后像H发送消息，H收到后会将ApplicationThread中的逻辑切换到ActivityThread中去执行，即切换到主线程中。