Android線程管理——線程通訊

標籤：

      線程通訊、ActivityThread及Thread類是理解Android線程管理的關鍵。

      線程，作為CPU調度資源的基本單位，在Android等針對嵌入式裝置的作業系統中，有著非常重要和基礎的作用。本小節主要從以下三個方面進行分析：

1. 《Android線程管理——線程通訊》
2. 《Android線程管理——ActivityThread》
3. 《Android線程管理——Thread》

一、Handler、MessageQueue、Message及Looper四者的關係

      在開發Android多線程應用時，Handler、MessageQueue、Message及Looper是老生常談的話題。但想徹底理清它們之間的關係，卻需要深入的研究下它們各自的實現才行。首先，給出一張它們之間的關係圖：

• Looper依賴於MessageQueue和Thread，因為每個Thread只對應一個Looper，每個Looper只對應一個MessageQueue。
• MessageQueue依賴於Message，每個MessageQueue對應多個Message。即Message被壓入MessageQueue中，形成一個Message集合。
• Message依賴於Handler進行處理，且每個Message最多指定一個Handler來處理。Handler依賴於MessageQueue、Looper及Callback。

      從運行機制來看，Handler將Message壓入MessageQueue，Looper不斷從MessageQueue中取出Message（當MessageQueue為空白時，進入休眠狀態），其target handler則進行訊息處理。因此，要徹底弄清Android的線程通訊機制，需要瞭解以下三個問題：

• Handler的訊息分發、處理流程
• MessageQueue的屬性及操作
• Looper的工作原理

1.1 Handler的訊息分發、處理流程

      Handler主要完成Message的入隊（MessageQueue）和處理，下面將通過Handler的源碼分析其訊息分發、處理流程。首先，來看下Handler類的方法列表：

     從中可以看出，Handler類核心的方法包括：1）構造器；2）分發訊息；3）處理訊息；4）post發送訊息；5）send發送訊息；6）remove訊息和回調。

     首先，從構造方法來看，構造器的多態最終通過調用如下方法實現，即將實參賦值給Handler類的內部域。

final MessageQueue mQueue;final Looper mLooper;final Callback mCallback;final boolean mAsynchronous;public Handler(Looper looper, Callback callback, boolean async) {    mLooper = looper;    mQueue = looper.mQueue;    mCallback = callback;    mAsynchronous = async;}

     其次，訊息的入隊是通過post方法和send方法來實現的。

public final boolean postAtTime(Runnable r, long uptimeMillis) {    return sendMessageAtTime(getPostMessage(r), uptimeMillis);}

public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {    Message msg = Message.obtain();    msg.what = what;    return sendMessageAtTime(msg, uptimeMillis);}

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

      兩者的區別在於參數類型不同，post方法傳入的執行個體對象實現了Runnable介面，然後在內部通過getPostMessage方法將其轉換為Message，最終通過send方法發出；send方法傳入的執行個體對象為Message類型，在實現中，將Message壓入MessageQueue。

private static Message getPostMessage(Runnable r) {    Message m = Message.obtain();    m.callback = r;    return m;}

      通過Handler將Message壓入MessageQueue之後，Looper將其輪詢後交由Message的target handler處理。Handler首先會對訊息進行分發。首先判斷Message的回調處理介面Callback是否為null，不為null則調用該Callback進行處理；否判斷Handler的回調介面mCallback是否為null，不為null則調用該Callback進行處理；如果上述Callback均為null，則調用handleMessage方法處理。

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

      handleMessage方法在Handler的子類中必須實現。即訊息具體的處理交由應用軟體實現。

/** * Subclasses must implement this to receive messages. */public void handleMessage(Message msg) {}

      回到Activity（Fragment），在Handler的子類中實現handleMessage方法。這裡需要注意一個記憶體泄露的問題，比較下述兩種實現方式，第一種直接定義Handler的實現，第二種通過靜態內部類繼承Handler，定義繼承類的執行個體。

Handler mHandler = new Handler() {                @Override    public void handleMessage(Message msg) {        super.handleMessage(msg);                    // 根據msg調用Activity的方法    }};

static class MyHandler extends Handler {    WeakReference<DemoActivity> mActivity;    public MyHandler(DemoActivity demoActivity) {        mActivity = new WeakReference<DemoActivity>(demoActivity);    }    @Override    public void handleMessage(Message msg) {        super.handleMessage(msg);        DemoActivity theActivity = mActivity.get();        // 根據msg調用theActivity的方法}

      不繞彎子，直接說明為什麼第一種方式會引起記憶體泄露，而第二種不會。

      在第一種方式中，mHandler通過匿名內部類方式執行個體化，在Java中，內部類會強持有外部類的引用（handleMessage方法中可以直接調用Activity的方法），在外部Activity調用onDestroy()方法之後，如果Handler的MessageQueue依然有未處理的訊息，那麼由於Handler持有Activity的引用導致Activity無法被系統GC回收，從而引起記憶體泄露。

      在第二種方式中，首先繼承Handler定義靜態內部類，由於MyHandler為靜態類，即使定義在Activity的內部，也與Activity沒有邏輯上的聯絡，即不會持有外部Activity的引用；其次，在靜態類內部，定義外部Activity的弱引用，弱引用在系統資源緊張時會被系統優先回收。最後，在handleMessage()方法中，通過WeakReference的get方法擷取外部Activity的引用，如果該弱引用已被回收，則get方法返回null。

struct GcSpec {  /* If true, only the application heap is threatened. */  bool isPartial;  /* If true, the trace is run concurrently with the mutator. */  bool isConcurrent;  /* Toggles for the soft reference clearing policy. */  bool doPreserve;  /* A name for this garbage collection mode. */  const char *reason;};

      這段代碼定義在dalvik/vm/alloc/Heap.h中，其中doPreserve為true時，表示在執行GC的過程中，不回收軟引用引用的對象；為false時，表示在執行GC的過程中，回收軟引用引用的對象。

      最後，使用Handler的過程中，還需要注意一點，在前面的方法列表圖中已經提到。為避免Activity調用onDestroy後，Handler的MessageQueue中仍存在Message，一般會在onDestroy中調用removeCallbacksAndMessages()方法。

@Overrideprotected void onDestroy() {    super.onDestroy();    // 清空Message隊列    myHandler.removeCallbacksAndMessages(null);}

public final void removeCallbacksAndMessages(Object token) {    mQueue.removeCallbacksAndMessages(this, token);}

      removeCallbacksAndMessages()方法會移除obj為token的由post發送的callback和send發送的message，當token為null時，會移除所有callback和message。

1.2 MessageQueue的屬性及操作

      MessageQueue，訊息佇列，其屬性與常規隊列相似，包括入隊、出隊等，這裡簡要介紹一下MessageQueue的實現。

      首先，MessageQueue建立隊列的工作是通過在其構造器中調用本地方法nativeInit實現的。nativeInit會建立NativeMessageQueue對象，然後賦值給MessageQueue成員變數mPtr。mPtr是int類型資料，代表NativeMessageQueue的記憶體指標。

MessageQueue(boolean quitAllowed) {    mQuitAllowed = quitAllowed;    mPtr = nativeInit();}

      其次，Message入隊的通過enqueueMessage方法實現。首先檢查message是否符合入隊要求（是否正在使用，target handler是否為null），符合要求後通過設定prev.next = msg隊列的指標完成入隊操作。

boolean enqueueMessage(Message msg, long when);

      再次，出隊是通過next()方法完成的。涉及到同步、鎖等問題，這裡不詳細展開了。

      再次，刪除元素有兩個實現。即分別通過p.callback == r和p.what == what來進行訊息識別。

void removeMessages(Handler h, int what, Object object);void removeMessages(Handler h, Runnable r, Object object);

      最後，銷毀隊列和建立隊列一樣，是通過本地函數完成的。傳入的參數為MessageQueue的記憶體指標。

private native static void nativeDestroy(int ptr);

1.3 Looper的工作原理

      Looper是線程通訊的關鍵，正是因為Looper，整個線程通訊機制才真正實現“通”。

      在應用開發過程中，一般當主線程需要傳遞訊息給使用者自訂線程時，會在自訂線程中定義Handler進行訊息處理，並在Handler實現的前後分別調用Looper的prepare()方法和loop()方法。大致實現如下：

new Thread(new Runnable() {                private Handler mHandler;                @Override    public void run() {        Looper.prepare();        mHandler = new Handler() {            @Override            public void handleMessage(Message msg) {                super.handleMessage(msg);                                    }        };        Looper.loop();    }});

這裡重點說明prepare()方法和loop()方法，實際項目中不建議定義匿名線程。

 

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

      可以看出，prepare方法的重點是sThreadLocal變數，sThreadLocal變數是什麼呢？

// sThreadLocal.get() will return null unless you‘ve called prepare().static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

      ThreadLocal實現了執行緒區域儲存。簡單看一下它的類註解文檔，ThreadLocal是一種特殊的全域變數，全域性在於它儲存於自己所線上程相關的資料，而其他線程無法訪問。

/** * Implements a thread-local storage, that is, a variable for which each thread * has its own value. All threads share the same {@code ThreadLocal} object, * but each sees a different value when accessing it, and changes made by one * thread do not affect the other threads. The implementation supports * {@code null} values. * * @see java.lang.Thread * @author Bob Lee */public class ThreadLocal<T> {}

      回到prepare方法中，sThreadLocal添加了一個針對當前線程的Looper對象。並且prepare方法只能調用一次，否則會拋出運行時異常。

      初始化完畢之後，Handler通過post和send方法如何保證訊息投遞到Looper所持有的MessageQueue中呢？其實，MessageQueue是Handler和Looper的橋樑。在前面Handler章節中提到Handler的初始化方法，Handler的mLooper對象是通過Looper的靜態方法myLooper()擷取的，而myLooper()是通過調用sThreadLocal.get()來得到的，即Handler的mLooper就是當前線程的Looper對象，Handler的mQueue就是mLooper.mQueue。

……mLooper = Looper.myLooper();if (mLooper == null) {   throw new RuntimeException(        "Can‘t create handler inside thread that has not called Looper.prepare()");}mQueue = mLooper.mQueue;……

public static Looper myLooper() {    return sThreadLocal.get();}

Android線程管理——線程通訊