Handler,Looper,MessageQueue流程梳理

目的：handle的出現主要是為瞭解決線程間通訊。舉個例子，android是不允許在主線程中訪問網路，因為這樣會阻塞主線程，影響性能，所以訪問網路都是放在子線程中執行，對於網路返回的結果則需要顯示在主線程中，handler就是連接主線程和子線程的橋梁。 1.handler基本使用方法看一下使用方 ...

目的：handle的出現主要是為瞭解決線程間通訊。

　　舉個例子，android是不允許在主線程中訪問網路，因為這樣會阻塞主線程，影響性能，所以訪問網路都是放在子線程中執行，對於網路返回的結果則需要顯示在主線程中，handler就是連接主線程和子線程的橋梁。

1.handler基本使用方法

　　看一下使用方法：

 public static final int EMPTY_MSG = 0;
    @SuppressLint("HandlerLeak")
    Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case 0:
                    Toast.makeText(MainActivitys.this, "接受到消息", Toast.LENGTH_SHORT).show();
                    break;
            }
        }
    };
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        new Thread(new Runnable() {
            @Override
            public void run() {
                handler.sendEmptyMessage(0);
            }
        }).start();
    }

　　通過上邊代碼就完成了子線程向主線程發送消息的功能。

2. handler，Looper，MessageQueue 解釋

　　handler：負責發送和處理消息

　　Looper：消息迴圈器，也可以理解為消息泵，主動地獲取消息，並交給handler來處理

　　MessageQueue：消息隊列，用來存儲消息

3.源碼分析

　程式的啟動是在ActivityThread的main方法中

public static void main(){
   Looper.prepare(); //1
   Handler handler = new Handler();//2
   Looper.loop();      //3
}

　　Looper.prepare()會初始化當前線程的looper

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

　　會調用到sThreadLocal.set()方法，ThreadLocal是線程安全的，不同的線程獲取到的值是不一樣的，下麵先分析一下ThreadLocal是如何做到線程安全。

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

　　不同的線程會設置不同的looper，下麵看一下ThreadLocalMap是如何存儲數據的

 ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
      table = new Entry[INITIAL_CAPACITY];
      int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
      table[i] = new Entry(firstKey, firstValue);    
}

　　ThreadLocalMap會創建一個數組，key是通過特殊的演算法來創建出來，一個線程中會有一個ThreadLocalMap,這個map中會存多個ThreadLocal和values。

　　下麵看下ThreadLocalMap是如何set一個值的

private void set(ThreadLocal key, Object value) {

            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);

            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal k = e.get();

                if (k == key) {
                    e.value = value;
                    return;
                }

                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

　　其實是遍歷threadLocalMap中的table，如果當前table中存在threadLocal這個key就更新，不存在就新建。ThreadLocal的set方法到此結束。

　　下麵看下Handler handler = new Handler()中執行了哪些操作：

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

　　重要的就是構造函數中這兩個方法，在handler中初始化looper和messageQueue。這個就不展開講了。

　　下麵看一下Looper.loop()這個步驟，我做了一些精簡，把無關的代碼去掉了。

   public static void loop() {
        final Looper me = myLooper();
        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);
            msg.recycleUnchecked();
        }
    }

　　queue.next()是個無限for迴圈，其實也是個阻塞方法，其中比較重要的是下麵這個方法，其作用是不會一直迴圈。底層採用的是pipe/epoll機制。

nativePollOnce(ptr, nextPollTimeoutMillis);

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

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

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

                // If first time idle, then get the number of idlers to run.
                // Idle handles only run if the queue is empty or if the first message
                // in the queue (possibly a barrier) is due to be handled in the future.
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }

                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

            // Run the idle handlers.
            // We only ever reach this code block during the first iteration.
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // release the reference to the handler

                boolean keep = false;
                try {
                    keep = idler.queueIdle();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }

                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }

            // Reset the idle handler count to 0 so we do not run them again.
            pendingIdleHandlerCount = 0;

            // While calling an idle handler, a new message could have been delivered
            // so go back and look again for a pending message without waiting.
            nextPollTimeoutMillis = 0;
        }
    }

　　message.next()返回消息之後會接著調用 msg.target.dispatchMessage(msg);在這個方法裡邊會進行判斷，來決定執行哪一種回調。

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

到此整個handler的流程就結束了。最後附上一張handler的時序圖。