• 目錄
• Handler匣椰、Looper芯义、MessageQueue源碼解析——Handler
• Handler、Looper坯墨、MessageQueue源碼解析——Looper
• Handler属提、Looper权逗、MessageQueue源碼解析——ThreadLocal
• Handler、Looper冤议、MessageQueue源碼解析——MessageQueue

MessageQueue

/**
* Low-level class holding the list of messages to be dispatched by a
* {@link Looper}. Messages are not added directly to a MessageQueue,
* but rather through {@link Handler} objects associated with the Looper.
* You can retrieve the MessageQueue for the current thread with
* {@link Looper#myQueue() Looper.myQueue()}.
*/

Handler時(shí)用來發(fā)送消息的斟薇，調(diào)用sendMessageAtTime()，在調(diào)用MessageQueue的enqueueMessage(msg, uptimeMillis)方法恕酸，把消息插入到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;
    }```

在Looper的loop()方法中，開啟了一個(gè)死循環(huán)尸疆，通過調(diào)用MessageQueue的next()方法，不斷的取出消息惶岭，再交給Handler去處理寿弱。

Message msg = queue.next();```

我們來看一下MessageQueue的next()方法：

    Message next() {
        //注釋1
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }

        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;
                //注釋2
                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());
                }
                //注釋3
                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;
                }

                // Process the quit message now that all pending messages have been handled.
                //注釋4
                if (mQuitting) {
                    dispose();
                    return null;
                }

    }```

首先看注釋1：mPrt==0時(shí)返回一個(gè)null，mPrt在什么時(shí)候?yàn)榭漳匕丛睿⒁獾接幸粋€(gè)dispose()方法：

private void dispose() {
    if (mPtr != 0) {
        nativeDestroy(mPtr);
        mPtr = 0;
    }
}```

dispose()方法在哪調(diào)用呢症革，注意到在注釋4處，當(dāng)mQuitting==true時(shí)調(diào)用dispose()方法鸯旁。那么mQuitting在哪賦值為true呢：

    void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }

            // We can assume mPtr != 0 because mQuitting was previously false.
            nativeWake(mPtr);
        }
    }```

也就是上節(jié)我們說到調(diào)用Looper中的quit()獲得quitSafely()時(shí)會(huì)賦值為true噪矛，MessageQueue退出循環(huán)量蕊。

再看注釋3:Message是一個(gè)單向鏈表，next指向下一個(gè)Message艇挨。首先會(huì)先判斷當(dāng)前時(shí)間與Message的時(shí)間對(duì)比：

//獲取從開機(jī)到現(xiàn)在的時(shí)間
final long now = SystemClock.uptimeMillis();

when = SystemClock.uptimeMillis()+uptimeMillis;```

如果message已經(jīng)準(zhǔn)備好残炮，則返回一個(gè)Message對(duì)象，并把Message的next指針指向下一個(gè)message缩滨。

再看注釋2:什么時(shí)候message的target對(duì)象為空势就，在Handler發(fā)送Message時(shí)制定了target對(duì)象，當(dāng)message的target對(duì)象為空時(shí)說明不是由Handler插入進(jìn)來的脉漏，在MessageQueue的源碼中找到這樣一個(gè)方法苞冯；

    private int postSyncBarrier(long when) {
        // Enqueue a new sync barrier token.
        // We don't need to wake the queue because the purpose of a barrier is to stall it.
        synchronized (this) {
            final int token = mNextBarrierToken++;
            final Message msg = Message.obtain();
            msg.markInUse();
            msg.when = when;
            msg.arg1 = token;

            Message prev = null;
            Message p = mMessages;
            if (when != 0) {
                while (p != null && p.when <= when) {
                    prev = p;
                    p = p.next;
                }
            }
            if (prev != null) { // invariant: p == prev.next
                msg.next = p;
                prev.next = msg;
            } else {
                msg.next = p;
                mMessages = msg;
            }
            return token;
        }
    }```
相當(dāng)于設(shè)置一個(gè)消息屏障，如果遇到一個(gè)消息屏障侧巨，就會(huì)不停的循環(huán)找到一個(gè)異步消息舅锄，一般我們使用的都是同步消息，我們可以通過Message的setAsynchronous(true)方法指定為異步消息司忱。

既然有開始循環(huán)皇忿，那么必定會(huì)有退出循環(huán)，我們調(diào)用Looper的quit()或者quitSafely()方法時(shí)實(shí)際調(diào)用的是MessageQueue的quit方法烘贴。quit()和quitSafely()方法的區(qū)別在Looper中已經(jīng)提到了禁添，分別調(diào)用了
removeAllMessagesLocked()和removeAllFutureMessagesLocked()方法，現(xiàn)在我們來看一下具體實(shí)現(xiàn)：

private void removeAllMessagesLocked() {
    Message p = mMessages;
    while (p != null) {
        Message n = p.next;
        p.recycleUnchecked();
        p = n;
    }
    mMessages = null;
}```

因?yàn)镸essage是一個(gè)單向鏈表桨踪，把所有的Message回收掉老翘。

   private void removeAllFutureMessagesLocked() {
       final long now = SystemClock.uptimeMillis();
       Message p = mMessages;
       if (p != null) {
           if (p.when > now) {
               removeAllMessagesLocked();
           } else {
               Message n;
               for (;;) {
                   n = p.next;
                   if (n == null) {
                       return;
                   }
                   if (n.when > now) {
                       break;
                   }
                   p = n;
               }
               p.next = null;
               do {
                   p = n;
                   n = p.next;
                   p.recycleUnchecked();
               } while (n != null);
           }
       }
   }```

當(dāng)p.when > now時(shí)，即又延時(shí)的消息全部清空锻离，對(duì)于沒有延時(shí)的消息铺峭，通過一個(gè)死循環(huán)等待Handler處理完再回收。

我們注意到無論是Looper的loop()方法還是MessageQueue的next()方法汽纠，都是一個(gè)死循環(huán)卫键，那么為什么不會(huì)造成阻塞或者對(duì)CPU有什么消耗上的影響？請(qǐng)參考知乎大神回答：[Android中為什么主線程不會(huì)因?yàn)長ooper.loop()里的死循環(huán)卡死虱朵？](https://www.zhihu.com/question/34652589)