Android 8.1 Handler 原始碼解析

Yuloran發表於2019-01-04

原始碼解析,如需轉載,請註明作者:Yuloran (t.cn/EGU6c76)

一. 前言

基於Android 8.1(API27) 原始碼,分析 Handler 的工作流程。

在 Android 系統中,Zygote 程式是首個 java 程式,同時也是所有 java 程式的父程式。上層應用開發工程師所關注的 App 程式 fork 自 Zygote 程式,App 程式建立後最後會通過反射,呼叫 ActivityThread 的 main() 方法,進而初始化主執行緒的 looper 和 handler。

二. 主執行緒 Looper 初始化

2.1 ActivityThread.main

ActivityThread.java

    public static void main(String[] args) {
        // 省略...
		
        // 初始化 UI 執行緒的 looper 物件
        Looper.prepareMainLooper();
        
        // 初始化 ActivityThread,進而初始化其成員變數 mH(Handler子類)
        ActivityThread thread = new ActivityThread();
        // 將 ApplicationThread(Binder) 物件 attach 到 ActivityManagerService(AMS)
        // 注:AMS 執行在 SystemServer 程式的一個執行緒中,負責排程四大元件等,通過 Binder 與 App 程式進行 IPC
        thread.attach(false);
        
        // 省略...
		
        // 主執行緒進入迴圈
        Looper.loop();
    }
複製程式碼

2.2 Looper.prepareMainLooper

Looper.java

    public static void prepareMainLooper() {
        // 初始化主執行緒 looper,不允許退出
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            // 初始化 sMainLooper,便於通過 new Handler(Looper.getMainLooper()) 方式向主執行緒發訊息
            sMainLooper = myLooper();
        }
    }
複製程式碼

2.3 Looper.prepare

Looper.java

    // sThreadLocal 為 ThreadLocal<Looper> 型別的靜態變數
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    
    private static void prepare(boolean quitAllowed) {
        // 一個執行緒只能有一個 looper 物件,否則丟擲異常
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        // 此處實際是將 looper 物件儲存到了 Thread.java 的成員變數 threadLocals(ThreadLocalMap) 中
        sThreadLocal.set(new Looper(quitAllowed));
    }
複製程式碼

sThreadLocal 物件是 Looper.java 中的靜態變數,故只要 Looper.class 不被 jvm 解除安裝,該變數就不會重新初始化。

2.4 Looper

Looper.java

    private Looper(boolean quitAllowed) {
        // 初始化 MessageQueue,因為一個執行緒只有一個 looper,所以也只有一個 MessageQueue 物件
        // 無論 new 多少個 Handler,其成員變數 mQueue 物件皆指向此處建立的 mQueue 物件 
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }
複製程式碼

2.5 ThreadLocal.set

ThreadLocal.java

    public void set(T value) {
        // 入參 values 是上面新建的 looper 物件
        Thread t = Thread.currentThread();
        // 獲取當前執行緒的成員變數 threadLocals 
        ThreadLocalMap map = getMap(t);
        // 此時 map == null
        if (map != null)
            map.set(this, value);
        else
            // 走這個分支
            createMap(t, value);
    }

	ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    void createMap(Thread t, T firstValue) {
	    // 入參 firstValue 是上面新建的 looper 物件
	    // 建立一個 ThreadlocalMap 物件,並把 looper 存至其中,最後賦值給成員變數 threadLocals
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }
複製程式碼

ThreadLocal 是一個泛型類,此處泛型為 Looper,它能實現每個執行緒擁有各自的 looper 而不產生競爭的原因是:它將每個執行緒的 looper 儲存到了各自的成員變數 threadLocals 中。

2.6 ThreadLocalMap

Thread.java

    ThreadLocal.ThreadLocalMap threadLocals = null;
    
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	    table = new Entry[INITIAL_CAPACITY];
	    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
	    // 儲存 looper 物件
	    table[i] = new Entry(firstKey, firstValue);
	    size = 1;
	    setThreshold(INITIAL_CAPACITY);
    }
複製程式碼

ThreadLocalMap 是自定義的一個資料結構,由陣列實現,其元素型別為 Entry。Entry 儲存一個鍵值對,key 始終為ThreadLocal<?> 型別,value 為 Object 型別。此處 key 即為 Looper.java 中的靜態變數 sThreadLocals,而 value 為之前建立的 looper 物件。

2.7 sMainLooper

Looper.java

    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            // 初始化 sMainLooper,便於通過 new Handler(Looper.getMainLooper()) 方式向主執行緒發訊息
            sMainLooper = myLooper();
        }
    }

    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }
複製程式碼

2.8 ThreadLocal.get

ThreadLocal.java

    public T get() {
        Thread t = Thread.currentThread();
        // 獲取當前執行緒的 threadLocals 物件,此處為 UI 執行緒
        ThreadLocalMap map = getMap(t);
        // 已經呼叫 prepare(false),此處 map 不為 null
        if (map != null) {
			// 這個 this 就是 sThreadLocal
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                // 此處 value 為 Object 型別,需要強轉為 Looper 型別
                T result = (T)e.value;
                // 返回該執行緒的 looper 物件
                return result;
            }
        }
        return setInitialValue();
    }
複製程式碼

至此,UI 執行緒的 looper 物件已經建立並且儲存到了 UI 執行緒的 threadLocals 物件中,並且賦值給了 Looper.java 的靜態變數 sMainLooper,以便在其它執行緒中,通過 new Handler(Looper.getMainLooper()) 方式向主執行緒發訊息。接下來看 Handler 的初始化。

三. Handler 初始化

3.1 Handler

Hanlder.java

    public Handler() {
        this(null, false);
    }

    public Handler(Callback callback, boolean async) {
        // 省略...
	
        // Handler 在哪個執行緒建立,取出來的就是哪個執行緒的 looper	
        mLooper = Looper.myLooper();
        // 未呼叫 Looper.prepare() 的執行緒,無法建立 Handler
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        // 指向建立 looper 時所建立的 MessageQueue 物件
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
複製程式碼

沒有 looper 就無法建立 Handler,同樣建立 Handler 時也可以為其指定 looper。

四. Handler 傳送訊息

4.1 Handler.sendEmptyMessage

Handler.java

    public final boolean sendEmptyMessage(int what)
    {
        return sendEmptyMessageDelayed(what, 0);
    }

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        // 從物件池中取出一個 Message 物件
        // 注:Message 物件使用後會被回收進物件池(大小為50),以便下次複用
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        // 入參保護
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        // 立即傳送訊息
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        // mQueue 就是這個 handler 所線上程對應的 looper 物件中的 mQueue 物件
        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) {
        // 將 handler 物件賦值給 msg 的 target
        msg.target = this;
        // mAsynchronous 預設是 false
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        // 呼叫 MessageQueue 的 enqueueMessage() 將訊息投入 MessageQueue
        // 注:不想翻譯成訊息佇列,因為一般說訊息佇列指的是 Linux IPC 方式的一種。
        return queue.enqueueMessage(msg, uptimeMillis);
    }
複製程式碼

4.2 MessageQueue.enqueueMessage

MessageQueue.java

    // MessageQueue 是由單向連結串列實現的、總是按照 msg.when 升序排序的佇列。
    // 其成員變數 mMessages 代表表頭。
    Message mMessages;

    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;
            // 初始狀態下,mMessages 為 null
            Message p = mMessages;
            boolean needWake;
            // 如果表頭為 null 或者新訊息的 when 小於表頭的 when,進入這個分支
            if (p == null || when == 0 || when < p.when) {
                // 入參 msg 的下一個節點指向當前表頭,即入參 msg 成為新的表頭
                msg.next = p;
                // 代表表頭的成員變數重新賦值
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // 如果表頭不為 null 且新訊息的 when 大於等於 表頭的 when,則進入這個分支
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                // 遍歷連結串列,找出下一節點為 null(即表尾) 或者 when 大於等於新訊息 when 的節點
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                // 如果未找到 when 大於等於新訊息 when 的節點,則將 msg 追加到表尾。
                // 否則將 msg 插入到該結點之前
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                // 新訊息入隊,需要喚醒,nativePollOnce() 才能返回
                nativeWake(mPtr);
            }
        }
        return true;
    }
複製程式碼

MessageQueue 是由單向連結串列實現的,總是按照 msg.when 升序排序的佇列。新傳送的訊息會插入到傳送時間比它晚的訊息之前。

五. Handler 處理訊息

5.1 Looper.loop()

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;

        // 迴圈讀取訊息並處理,無訊息時阻塞。這種寫法是最常用的 Linux IO 操作方式。
        for (;;) {
            // 取出一個訊息,若沒有訊息要處理,則阻塞
            Message msg = queue.next(); // 可能阻塞
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                // 呼叫 handler 的 dispatchMassage() 分發訊息
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
			
            // 回收進物件池
            msg.recycleUnchecked();
        }
    }
複製程式碼

5.2 MessageQueue.next()

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

        int pendingIdleHandlerCount = -1; // -1 only during first iteration
        int nextPollTimeoutMillis = 0;
        // 注意此處也是一個 for 迴圈
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
			
            // native 層阻塞函式,nextPollTimeoutMillis 為超時時間,首次迴圈時值為0,即直接返回
            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) {
                        // 下一個訊息還沒到處理時間,則設定超時時間為還需等待的時間,進入阻塞狀態.
                        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 需要取走處理,故需要從連結串列中斷開
                        msg.next = null;
                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                        // 標記為使用中
                        msg.markInUse();
                        // 返回要處理的訊息
                        return msg;
                    }
                } else {
                    // 沒有訊息要處理,超時時長為-1,迴圈並等待
                    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,進入阻塞狀態,有新訊息入隊時,會呼叫 nativeWake() 喚醒
                    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;
        }
    }
複製程式碼

5.3 Handler.dispatchMessage###

Handler.java

    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
	        // 如果 msg 的 callback 不為 null,則執行 msg 的 callback
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                 // 如果 handler的 callback 不為 null,則執行 handler的 callback
                if (mCallback.handleMessage(msg)) {
                    // 如果 callback 的 handleMessage() 返回 true,則不再呼叫 handler 的 handleMessage()
                    return;
                }
            }
            // 呼叫 handler 的 handleMessage()
            handleMessage(msg);
        }
    }
複製程式碼

六. 總結

  • 一個執行緒只有一個 looper 和 一個 messageQueue,handler 可以建立無數個
  • MessageQueue 是單向連結串列實現的,新訊息入隊時,會根據 when 找到合適的位置並插入(即總是按照 msg.when 升序)
  • Message 運用了物件池技術,可通過 obtain()、recycle() 獲取和回收訊息
  • 沒有訊息處理時,執行緒會被掛起,直到有新訊息時才會被喚醒執行,底層是通過 IO 多路複用機制中的 epoll 實現的,詳見 MIUI 系統工程師 Gityuan 的 Android訊息機制2-Handler(Native層)
  • 除了 Java 層有訊息需要處理,Native 層也有自己的訊息需要處理,二者是獨立的,只不過共用了 Native 層的 MessageQueue 和阻塞喚醒機制。由於訊息處理流程總是先處理 Native Message,再處理 Native Request,最後處理 Java Message,所以有時候 Java 層訊息很少,但響應時間卻較長:

Android 8.1 Handler 原始碼解析

圖片來自 MIUI 系統工程師 Gityuan 的 Android訊息機制2-Handler(Native層)

相關文章