Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 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();
}

  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved