Android 非同步任務知識梳理(2) HandlerThread 原始碼解析

澤毛發表於2017-12-13
Android非同步thread原始碼

一、概述

剛開始接觸HandlerThread是在看AsyncQueryHandler原始碼的時候，第一次眼看到HandlerThread這個名字，就在想這到底是個Handler還是個Thread，後來看了原始碼才發現它其實就是一個Thread，只不過可以通過它的getLooper返回的Looper作為Handler建構函式的引數，那麼這個新建Handler所有message的執行都是在這個對應的Thread當中的，關於在專案當中如何用好HandlerThread，AsyncQueryHandler無疑是一個最好的例子。

二、原始碼

HandlerThread的程式碼很少，我們一點點看：

int mPriority; //執行緒的優先順序
int mTid = -1; //執行緒對應的pid，結束時為-1。
Looper mLooper; //對應的looper
複製程式碼

再看一下run方法：

<!-- HandlerThread.java -->
@Override
public  void run() {    
    mTid = Process.myTid();    
    Looper.prepare();    
    synchronized (this) {        
        mLooper = Looper.myLooper();         
        notifyAll();    
    }     
    Process.setThreadPriority(mPriority);     
    onLooperPrepared();    
    Looper.loop();    
    mTid = -1;
}
複製程式碼

第一步先呼叫了Looper.prepare()方法來初始該執行緒的Looper，它其實是新建了一個Looper（這個 Looper是可以退出迴圈的），儲存到sThreadLocal變數當中，這個變數是static final ThreadLocal<Looper>型別的，也就是每個Thread有一份不同的例項，並且在每個執行緒中也只允許初始化一次：

<!-- Looper.java -->

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

public static void prepare() {    
     prepare(true);
}

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));
}
複製程式碼

之後拿出這個新建的Looper儲存起來，同時設定執行緒的優先順序，接著呼叫Looper.loop()方法，在這之前會回撥給onLooperPrepared，因為如果Looper.loop()開始執行後，那麼就是一個無限迴圈，使用者沒法進行初始化操作了：

<!-- Looper.java -->
public static void loop() {
     final Looper me = myLooper();
     if (me == null) {
         //exception;
     }
     final MessageQueue queue = me.mQueue;
     Binder.clearCallingIdentity();
     final long ident = Binder.clearCallingIdentity();
     for (;;) {
        //這裡面會呼叫 nativePollOnce(ptr, nextPollTimeoutMillis) 等待有新的訊息出現，否則就一直阻塞在這裡;
        Message msg = queue.next();
        //如果新的訊息為null，那麼就退出這個迴圈。
        if (message == null) {
            return;
        }
        //分發有效的訊息。
        msg.target.dispatchMessage(msg);
        msg.recycleUnchecked();
     }
}

<!-- MessageQueue.java -->
Message next() {
   final long ptr = mPtr;
   if (ptr == null) {
      return null;
   }
   for (;;) {
       //會休眠在這裡，直到通過mPtr被喚醒。 
       nativePollOnce(ptr, nextPollTimeoutMillis);
       //被喚醒後，從佇列中去除訊息進行處理。
   }
}
複製程式碼

接下來看一下getLooper()方法，如果此時mLooper還沒有被初始化，那麼它會一直休眠在這裡：

<!-- HandlerThread.java -->
public Looper getLooper() {
    //如果執行緒沒有存活，那麼退出。    
    if (!isAlive()) {        
        return null;    
    }          
    synchronized (this) {
        //如果執行緒存活，但是沒有開始執行，那麼等待。        
        while (isAlive() && mLooper == null) {             
            try {                
                wait();            
            } catch (InterruptedException e) {}         
        }    
     }    
     return mLooper;
}
複製程式碼

這下來看一下退出的兩個方法，它們的區別就是safe方法會保證當前佇列當中的Message都被執行完畢，但那些delay的訊息不會被遞送。

<!-- HandlerThread.java -->
public boolean quit() {    
    Looper looper = getLooper();    
    if (looper != null) {        
        looper.quit();        
        return true;    
    }    
    return false;
}

public boolean quitSafely() {    
    Looper looper = getLooper();    
    if (looper != null) {        
        looper.quitSafely();        
        return true;    
    }    
    return false;
}
複製程式碼

quit其實是呼叫了和Looper關聯的MessageQueue對應的quit(boolean safe)方法：

<!-- Looper.java -->
public void quit() {    
    mQueue.quit(false);
}

public void quitSafely() {      
    mQueue.quit(true);
}

<!-- MessageQueue.java -->
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();    
        }
        //喚醒迴圈，使得 loop 知道，mQuitting 的變化    
        nativeWake(mPtr);
    }
}
複製程式碼

可以看到這裡把mQuitting置為了true，之後通過nativeWake使Message.next()中 原先阻塞的 nativePollOnce繼續往下執行並且會返回null，當Looper.loop()中的queue.next()返回null ，那麼 Looper.loop()也跟著退出了。 由此可見當我們例項化一個HandlerThread物件，之後又呼叫了quitXXX方法，那麼它就停止了這個迴圈，相當於這個Looper物件在這個執行緒中雖然存在，但是無法通過它做任何操作了，即使我們第二次執行它的run方法，呼叫Looper.prepare()的時候，也會因為sThreadLocal.get() != null而丟擲異常。

三、結論

可以看到，HandlerThread就是建立了一個執行緒，當我們呼叫它的start()方法時，也就是執行它的run方法，其實就是建立一個與他相關聯的Looper，並讓這個Looper跑起來，這個Looper中所有訊息的處理都是在這個新建的執行緒當中的，呼叫者可以通過這個Looper進行後續的操作。

相關文章