Android每天面試一題--Android的Handler機制

我們在面試的時候經常會被問到Handler機制，我們一般回答的很簡單，比如答到用來發送及處理消息，處理子線程向主線程發出的消息。對於面試官而言，這或許並不是他們想要的答案。今天，我打算從源碼的角度去追溯一下，Handler究竟是怎麼樣的一個執行機制。

首先，我們知道Handler裏面發送消息包含了下面的幾種方式
例如：

• sendMessage(Message msg)
• sendEmptyMessage(int what)
• obtainMessage(int what, Object obj).sendToTarget();

首先，我們進入到Handler.jave類，查看sendMessage(Message msg)方法

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

上面的代碼依次又調用了sendMessageDelayed(msg, 0);

    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

做了一個判斷，由於傳進來的是0，我們可以忽略掉上面的判斷，直接看下面的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);
    }

上面我們看到的是拿了一個MessageQueue對象，假設我們的這個對象不爲空，跳過判斷，直接我們在接着看下面的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);
    }

queue.enqueueMessage(msg, uptimeMillis);主要做的就是將msg消息裝在MessageQueue這個對象中

---

下面我們看一下，怎麼把Message拿出來？

Handler.java類的構造方法

   public Handler(Callback callback, boolean async) {
       ```
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

不錯， mQueue = mLooper.mQueue; 一看，是Looper裏面來的。
下面我們就要分析一下，Looper是個啥？跟MessageQueue有什麼關係？

mLooper = Looper.myLooper();

   static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
 
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

Looper的實例對象，在每一個線程中獨立存在。也就是Looper拿到Thread的實例對象引用

ThreadLocal是什麼呢？

ThreadLocal也是爲了解決共享數據（對象）的問題，同步鎖的思路是線程不能同時訪問一片內存區域，而ThreadLocal的思路是，乾脆給每個線程Copy一份一抹一樣的對象，各自玩自己的，互相不影響。

這樣，就拿到mLooper,然後mLooper調用loop()方法，獲取到MessageQueue,拿出Message
Looper.java

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

上面我們還遺留了一個問題，MessageQueue是怎麼來的？
在看代碼的時候，發現 MessageQueue queue = mQueue;，那mQueue是怎麼賦值的？

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

大致我們清楚了，我們在handler發送Meesage，有這個幾個過程？

1、當我們調用snedMessage(msg)的時候，Handler類裏面會啓用Looper類裏面的Looper方法,創建MessageQueue，並獲取當前線程的引用。然後將msg存進去

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

2、當我們去拿數據的時候，由於我們的Looper.loop()方法在回調handleMessage(Message msg)方法後執行。它會不停的拿到當前的MessageQueue,從而遍歷消息。