了解Handler消息机制前需要先了解Handler在实例化做了什么操作。

实例化

Handler初始化时会获取当前线程的Looper的消息队列（）作为自己的消息队列。也就是说在同一个线程中创建的多个Handler其实用的是同一个消息队列，也就是当前线程->Looper->消息队列。

    public Handler(Callback callback, boolean async) {
        //......
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            //子线程需要手动调用  Looper.prepare() 才会创建该线程的唯一且不可替换的 Looper
            //而主线程在启用时就主动进行了初始化，所以不需要手动调用
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

发送消息

向Handler发送消息时，不过是通过什么方式发送，最后都会到达sendMessageAtTime()方法进行处理。
该方法的作用设置Message的target为Handler本身，然后把Message入队到上面实例化时提到的消息队列中。
这里设置的Message.target就是为了能让指定的Handler处理消息。

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

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

处理消息

上面提到，向Handler发送消息其实就是讲详细添加到了Looper的消息队列里面。那Looper有是如何处理消息的呢？这里先提前说下实现方式，后面再看源码。

1. Looper执行loop()方法后会进入一个死循环，作用是从MessageQueue中获取消息并派发给Message.target进行处理。直到获取到空消息时才会退出循环。
2. MessageQueue的next()方法里面也会进入一个死循环，不断从消息队列中出队消息并返回给Looper，直到messageQueue.quit()方法被调用后才会返回空消息，继而让loop()方法退出循环。
3. messageQueue.next()在进入循环后会调用nativePollOnce(ptr, nextPollTimeoutMillis)设置一个有超时时间的阻塞。而在入队方法messageQueue.enqueueMessage()中会调用nativeWake(mPtr)取消阻塞。这也是Looper的死循环不会出现问题的原因。
   （有兴趣可以自己了解下nativePollOnce、nativeWake方法）
4. 延时执行消息也是通过设置nativePollOnce()的超时时间来实现的
5. 从代码可以看出，消息队列是用链表来实现的。

以下是Looper和MessageQueue的部分源码
Looper.java

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

            //......

            msg.target.dispatchMessage(msg);

        //......
      }

MessageQueue.java

    Message next() {
        // Return here if the message loop has already quit and been disposed.
        // This can happen if the application tries to restart a looper after quit
        // which is not supported.
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        //......

        // next()方法里面也用了死循环，这才是Looper没有退出loop的原因
        for (;;) {
           
            //......

            // 阻塞队列（休眠）用的，防止死循环问题。
            // 调用enqueueMessage()方法入队的时候会调用nativeWake(mPtr)唤醒队列
            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.
                    // 如果msg没有target就会被跳过，直到获取到没异步的消息为止
                    do {
                        prevMsg = msg;
                        msg = msg.next;
                    } while (msg != null && !msg.isAsynchronous());
                }
                if (msg != null) {
                    if (now < msg.when) {
                        // 当Message没有到延时执行的时间时，会设置唤醒时间，并在下次循环调用上面的nativePollOnce(ptr, nextPollTimeoutMillis)设置有超时时间的阻塞，然后获取下一个消息。
                        // 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;
                }

                // 当Looper调用了quit()方法的时候，会调用MessageQueue的quit()方法，继而设置mQuitting为true，这样next()方法才会返回空，Looper.loop()方法才会跳出循环然后结束掉。
                // Process the quit message now that all pending messages have been handled.
                if (mQuitting) {
                    dispose();
                    return null;
                }