Android教程網 >> Android技術 >> Android開發 >> 關於android開發 >> Android線程管理——線程通信，android線程通信

Android線程管理——線程通信，android線程通信

編輯：關於android開發

Android線程管理——線程通信，android線程通信

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

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

一、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()方法。

@Override
protected 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開發

開發入門初級開發中級開發高級開發關於android開發

相關文章

Android線程管理&mdash;&mdash;線程通信，android線程通信