Android Handler 訊息機制詳述

第一次在掘金上發表文章，生怕說錯了什麼誤人子弟，更不敢標題黨。
如果文章有誤，歡迎您直接在評論指出。

一. What、Handler 是什麼

Handler 與 Message、MessageQueue、Looper 一起構成了 Android 的訊息機制，Android 系統通過大量的訊息來與使用者進行互動，View 的繪製、點選事件、Activity 的生命週期回撥等都作為訊息由主執行緒的 Handler 來處理。

Handler 在訊息機制中的作用是：傳送和處理訊息。

Handler 還有另一個重要的作用，跨執行緒通訊。最常見的就是子執行緒請求網路，然後使用 Handler 將請求到的資料 post 到主執行緒重新整理 UI，大名鼎鼎的 Retrofit 也是這麼做的。

二. How、如何使用 Handler

• 建立 Handler

  private Handler handler = new Handler() {
    // 重寫 handleMessage 來根據不同 what 來處理 Message
    // 這個方法在 Handler 建立的執行緒執行
    @Override public void handleMessage(Message msg) {
          super.handleMessage(msg);
          switch (msg.what) {
              case 0:
                MLog.i(msg.obj);
                break;
              case 1:
                break;
              default:
  
          }
      }
  };複製程式碼

• 建立併傳送 Message

  // 獲取一個 Message
  Message message = Message.obtain();
  message.what = 0;
  message.obj = new Object();
  // 使用 Handler 傳送 Message
  // 訊息傳送完成後 Handler 的 handleMessage(Message msg) 會處理訊息
  handler.sendMessage(message);
  
  // 延遲 1s 傳送 Message
  handler.sendMessageDelayed(message, 1000);
  // 傳送一個空的 Message
  handler.sendEmptyMessage(msg.what);  
  // 延遲傳送一個空的 Message
  handler.sendEmptyMessageDelayed(0, 1000);
  
  // 還可以這樣
  // 建立 Message 並繫結 Handler
  Message message = handler.obtainMessage();
  message.what = 0;
  message.obj = new Object();
  
  // 傳送 Message
  message.sendToTarget();複製程式碼

• 使用 Handler 子執行緒請求資料，主執行緒重新整理 UI

  // 1. 在主執行緒建立 Handler（略）
  // 2. 子執行緒請求資料，主執行緒重新整理 UI
  new Thread(new Runnable() {
      @Override public void run() {
          // 獲取網路資料
          final List<Object> datas = getNetData();
  
          // 方法一：將資料作為 Message 的 obj 傳送出去，在 handleMessage 中重新整理 UI
          Message msg = Message.obtain();
          msg.what = 1;
          msg.obj = data;
          handler.sendMessage(msg);
  
          // 方法二：直接在 post 中重新整理 UI
          handler.post(new Runnable() {
              @Override public void run() {
                // 使用 datas 重新整理 UI
                // 這個方法也會在 Handler 建立的執行緒執行
              }
          });
      }
  }).start();複製程式碼

三. Handler 的記憶體洩漏

不得不說，上面使用 Handler 的方法會有記憶體洩漏的風險

• Handler 記憶體洩漏的兩個原因

  • Java 中非靜態內部類和匿名內部類會持有外部類的引用

    // 這是一個外部類 Handler 不會持有外部類引用
    // 顯然 handleMessage 沒地方寫了
    Handler handler = new Handler();
    
    // 重寫 handleMessage 後將得到一個內部類 Handler，以內 handleMessage 是在外部類中實現的
    // 它持有外部類引用，可能會引起記憶體洩漏
    Handler handler = new Handler() {
      @Override public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case 0:
                  MLog.i(msg.obj);
                  break;
                case 1:
                  break;
                default:
    
            }
        }
    };
    
    // 這裡 Handler 是一個匿名類，但不是內部類
    // Runnable 是一個匿名內部類，持有外部類引用，可能會引起記憶體洩漏
    new Handler().post(new Runnable() {
        @Override public void run() {
          // ...
        }
    });複製程式碼

    ​

  • Handler 的生命週期比外部類長。

• 分析

  • 非靜態的內部 Handler 子類、匿名 Handler 子類會持有外部類的引用(Activity)，而 Handler 可能會因為要等待處理耗時操作導致存活時間超過 Activity，或者訊息佇列中存在未被 Looper 處理的 Message ，而 Message 會持有 Handler 的引用。於是，在 Activity 退出時，其引用還是被 Handler 持有，導致 Activity 無法被及時回收，造成記憶體洩露。
  • 非靜態的內部 Runnable 子類、匿名 Runnable 子類 post 到任意 Handler 上時，Runnable 其實是 Massage中的 Callback，持有 Message 引用，如果這個 Massage 在訊息佇列還沒有被處理，那麼就會造成 Runnable 一直持有外部類的引用而造成記憶體洩露。

• 解決方案：

  • 通過靜態內部類或者外部類來宣告 Handler 和 Runnable。
  • 通過弱引用來拿到外部類的變數。
  • 在 Activity/Fragment 銷燬的時候請空 MessageQueue 中的訊息。

• 程式碼

  // Handler 弱引用封裝
  public class SafetyHandler<T> extends Handler {
      /**
       * 外部引用, 例如 Activity, Fragment, Dialog, View 等
       */
      private WeakReference<T> mTargetRef;
      public SafetyHandler() {
      }
      public SafetyHandler(T target) {
          this.mTargetRef = new WeakReference<>(target);
      }
  
      public T getTarget() {
          if (isTargetAlive()) {
              return mTargetRef.get();
          } else {
              removeCallbacksAndMessages(null);
              return null;
          }
      }
  
      public void setTarget(T target) {
          this.mTargetRef = new WeakReference<>(target);
      }
  
      private boolean isTargetAlive() {
          return mTargetRef != null && mTargetRef.get() != null;
      }
  }
  
  // 在 Fragment 中使用方法
  // 想重寫 handleMessage 的話，要建立靜態內部類或者外部類，否則有記憶體洩漏風險
  private static class MyHandler extends SafetyHandler<MyFragment> {
  
      MyHandler(MyFragment fragment) {
            super(fragment);
      }
  
      @Override public void handleMessage(Message msg) {
          super.handleMessage(msg);
          if(getTarget() != null) {
              MyFragment fragment = getTarget();
              switch (msg.what) {
                 // 操作 fragment
              }
          }
      }
  }
  
  // 宣告 Handler
  MyHandler handler = new MyHandler(this);
  
  // 使用 Handler
  handler.sendMessage() ...
  
  // onDestroy   
  @Override public void onDestroy() {
        super.onDestroy();
        handler.removeCallbacksAndMessages(null);
  }複製程式碼

  ​

四. Why、Handler 訊息機制的原理

這部分從 ActivityThread 的 main 方法出發，打通整個訊息機制的流程，結合原始碼體驗效果更佳。

概述

介紹訊息機制的原理前，我們先來看一下 Handler 與 Message、MessageQueue、Looper 這個四個類的作用

• Handler：前面已經說過，Handler 負責傳送和處理 Message。
• Message：訊息，負責傳遞標示(what) 和資料(obj) ；每個 Message 都會通過 target 這個成員變數來繫結一個 Handler，由這個 Handler 來傳送和處理 Message。
• MessageQueue：訊息佇列，負責存放有 Handler 傳送過來的訊息；每個 Handler 中都有一個 final MessageQueue mQueue，Handler 傳送訊息就是把訊息加入這個 MessageQueue 。
• Looper：負責不斷的從 MessageQueue 中取出訊息然後交給 Handler（Message#target ） 處理；每個 Looper 中都有一個唯一的訊息佇列（final MessageQueue mQueue），每個 Handler 中都有一個 final Looper mLooper，Handler 中的 MessageQueue 就是來自 Looper。

注意：每個執行緒只能有一個 Looper 和 一個 MessageQueue，可以有多個 Handler，每個 Handler 可以傳送和處理多個 Message。

另外，提到訊息機制就不得不說一下 Android 中的主執行緒（UI 執行緒）

Android 中的主執行緒通過 Looper.loop() 進入一個無線迴圈中，不斷的從一個 MessageQueue 取出訊息，處理訊息，我們每觸發一個事件，就會向這個 MessageQueue 中新增一個訊息，Looper 取出這個訊息，Handler 處理這個訊息，正是 Looper.loop() 在驅動著 Android 應用執行下去 ，這也是為什麼 Looper.loop 為什麼不會阻塞住主執行緒的原因（當然前提是在 ActivityThread 的 main 函式 中呼叫）。

正式進入原始碼分析

本原始碼分析基於 API 25，以下原始碼中刪除了一些無關的程式碼

1、在主執行緒的入口，ActivityThread 的 main 方法

public static void main(String[] args) {
        // 準備主執行緒的 Looer        
        Looper.prepareMainLooper();
        // 建立 ActivityThread
        ActivityThread thread = new ActivityThread();
        thread.attach(false);
        // 獲取主執行緒的 Handler 
        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        // 對訊息佇列進行無線輪詢，處理訊息
        Looper.loop();
        // 一旦跳出迴圈，丟擲異常（Android 不允許跳出主執行緒的 Looper.loop()）
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }複製程式碼

-> Looper.prepareMainLooper()

public static void prepareMainLooper() {
        // 準備一個 Looper
        prepare(false);
        synchronized (Looper.class) {
            // main Looper 只能初始化一次，再次初始化會丟擲異常
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            // 獲取 main Looper
            sMainLooper = myLooper();
        }
    }複製程式碼

-> prepare(false)

// 準備一個 Looper，quitAllowed 是否允許 Looper 中的 MessageQueue 退出
// 預設 prepare() 允許退出，主執行緒這裡不允許退出
private static void prepare(boolean quitAllowed) {
    // 先看下 sThreadLocal 是什麼
    // static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    // ThreadLocal:執行緒本地儲存區，每個執行緒都有本地儲存區域，這個區域是每個執行緒私有的，不同的執行緒不能之間不能彼此訪問
    // 如果 sThreadLocal 中有資料，丟擲異常，換句話說 prepare() 這個函式每個執行緒只能執行一次
    if (sThreadLocal.get() != null) {
          throw new RuntimeException("Only one Looper may be created per thread");
    }
    // 建立 Looper 儲存到該執行緒的 ThreadLocal 中
    sThreadLocal.set(new Looper(quitAllowed));
}複製程式碼

-> new Looper(quitAllowed)

private Looper(boolean quitAllowed) {
    // 在 Looper 建立的時候建立一個訊息佇列
    // quitAllowed:訊息佇列是否可以退出，主線的訊息佇列肯定不允許退出，所以上面是 prepare(false)
    // quitAllowed 為 false 執行 MessageQueue#quit 退出訊息佇列時會出現異常
    mQueue = new MessageQueue(quitAllowed);
    // 獲取 Looper 存在於哪個執行緒
    mThread = Thread.currentThread();
}複製程式碼

-> sMainLooper = myLooper()

public static @Nullable Looper myLooper() {
    // 從 sThreadLocal 中獲取當前執行緒的 Looper 
    // 如果當前執行緒沒有掉用 Looper.prepare 返回 null
    return sThreadLocal.get();
}複製程式碼

-> sMainThreadHandler = thread.getHandler();

final Handler getHandler() {
    // 返回 mH
    return mH;
}

// mH 在成員變數的位置 new H()
final H mH = new H();

// H 繼承了 Handler 封裝了一系列關於 Acitivty、Service 以及其他 Android 相關的操作
private class H extends Handler複製程式碼

總結：在主執行緒的 main 方法中，會建立主執行緒的 Looper、MessageQueue，然後進入 Looper.loop() 迴圈中，不斷的取出訊息，處理訊息，以此來驅動 Android 應用的執行。

2、Handler 的建立，Handler 的所有構造方法都會跳轉到下面兩個之一

public Handler(Callback callback, boolean async) {
    // Hanlder 是匿名類、內部類、本地類時，如果沒有宣告為 static 則會出現記憶體洩漏的警告
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
            (klass.getModifiers() & Modifier.STATIC) == 0) {
              Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName());
        }
    }

    // 獲取 Looper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
          throw new RuntimeException("Can`t create handler inside thread that has not called Looper.prepare()");
    }
    // 訊息佇列，從 Looper 中獲取
    mQueue = mLooper.mQueue;
    // 處理訊息的回撥介面
    mCallback = callback;
    // 處理訊息的方式是否為非同步，預設同步
    mAsynchronous = async;
}

public Handler(Looper looper, Callback callback, boolean async) {
    mLooper = looper;
    mQueue = looper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}複製程式碼

總結：在 Handler 的構造方法中，Handler 和 Looper、MessageQueue 繫結起來，如果當前執行緒沒有 Looper 丟擲異常（這也是為什麼直接在子執行緒建立 Handler 會出現異常）。

3、使用 Handler 傳送訊息

-> sendMessageAtTime(Message msg, long uptimeMillis)

// 除了 sendMessageAtFrontOfQueue，Handler 所有的 post、sendMessage 都會跳到這個方法
// Message msg: 要傳送的訊息
// long uptimeMillis: 傳送訊息的絕對時間，通過 SystemClock.uptimeMillis() 加上我們自己的延遲時間 delayMillis 計算而來
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
    MessageQueue queue = mQueue;
    // 訊息佇列為空（可能已經退出）返回 false 入隊失敗
    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);
}複製程式碼

-> sendMessageAtFrontOfQueue(Message msg)

// 傳送訊息到 MessageQueeu 的隊頭
public final boolean sendMessageAtFrontOfQueue(Message msg) {
    MessageQueue queue = mQueue;
    if (queue == null) {
        RuntimeException e = new RuntimeException(
        this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
        return false;
    }
    // 通過設定 uptimeMillis 為 0，是訊息加入到 MessageQueue 的隊頭
    return enqueueMessage(queue, msg, 0);
}複製程式碼

-> enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)

// 所有 Handler 的 post 、sendMessage 系列方法和 runOnUiThread 最終都會呼叫這個方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    // msg.target 是一個 Handler，將 Message 和 Handler 繫結
    // 也就是用哪個 Handler 傳送訊息，這個 Message 就和哪個 Handler 繫結
    msg.target = this;
    // 如果設定了訊息處理方式為非同步處理
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    // MessageQueue 的方法，將訊息入隊
    return queue.enqueueMessage(msg, uptimeMillis);
}複製程式碼

-> MessageQueue#enqueueMessage(Message msg, long when)

boolean enqueueMessage(Message msg, long when) {
        // Messgae 沒有繫結 Handler 丟擲異常
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        // Messgae 正在使用 丟擲異常
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            // 訊息佇列正在退出，回收 Message
            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();  // 呼叫 Message#recycleUnchecked() 
                return false;
            }
            msg.markInUse();  // 標記 Message 正在使用
            msg.when = when;  // 設定 Message 的觸發時間

            // mMessages 記錄著 MessageQueue 的隊頭的訊息 
            Message p = mMessages;  
            boolean needWake;
            // MessageQueue 沒有訊息、Message 觸發時間為 0、Messgae 觸發時間比隊頭 Message 早
            // 總之這個 Message 在 MessageQueue 中需要最先被分發
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;     // 將以前的隊頭 Message 連結在這個 Message 後面
                mMessages = msg;  // 將這個 Message 賦值給 mMessages
                needWake = mBlocked;  // 佇列是否阻塞
            } else {
                // 標記佇列是否阻塞
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;

                // 按照時間順序將 Message 插入訊息佇列
                for (;;) {
                    prev = p;   // prev 記錄隊頭
                    p = p.next; // p 記錄隊頭的後一個
                    // 隊頭後面沒有訊息或者其觸發事件比要插入的 Message 晚，跳出迴圈
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                // 將 Message 插入佇列
                msg.next = p; 
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }複製程式碼

總結：到現在為止，我們的 Handler 已經將 Message 傳送到了 MessageQueue，Message 靜靜的等待被處理。

4、Looper.loop() 還記得這個方法在 ActivityThread 的 main 呼叫了嗎？正是它在不斷處理 MessageQueue 裡面的訊息。

 public static void loop() {
        // 獲取 Looper.Looper.prepare 準備好的 Looper
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn`t called on this thread.");
        }
        // 獲取 Looper 中的訊息佇列
        final MessageQueue queue = me.mQueue;

        // 進入無線迴圈
        for (;;) {
            // 取出下一條訊息
            Message msg = queue.next(); 

            // 沒有訊息，退出 loop
            // 其實上面 queue.next() 也是一個無限迴圈，獲取到訊息就返回，沒有訊息就一直迴圈
            if (msg == null) {
                return;
            }

            try {
                // msg.target 實際上就是一個 Handler
                // 獲取到了訊息，使用繫結的 Handler#dispatchMessage 分發訊息
                msg.target.dispatchMessage(msg);
            } finally {

            }

            // 釋放訊息，把 Message 的各個變數清空然後放進訊息池中
            msg.recycleUnchecked();
        }
    }複製程式碼

5、Handler#dispatchMessage(msg) 訊息是如何處理的

public void dispatchMessage(Message msg) {
    // 1
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        // 2
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 3. 看到這個方法沒有！就是我們建立 Handler 時重寫的 handleMessage
        // OK 整個流程打通！
        handleMessage(msg);
    }
}複製程式碼

總結：流程雖然通了，但是處理 Message 的方法貌似有三種(我標記了序號)，而且我們的 handleMessage 的優先順序最低，其他方法會在什麼情況下執行呢？ 直接說結論了，呼叫 Handler 的 post 系列方法會走序號1的處理，建立 Handler 傳入 Callback 會走序號2 的處理。

Handler 機制總結：想使用 Handler 必須要有 Looper，建立 Looper 的時候會建立 MessageQueue，在 Handler 的構造的時候會繫結這個 Looper 和 MessageQueue，Handler 將 Message 傳送到 MessageQueue 中，Looper.loop() 會不斷的從 MessageQueue 取出訊息再交給這個 Handler 處理。

五. HandlerThread 的使用及原始碼解讀

在子執行緒中能直接建立 Handler 嗎？

• new Thread(new Runnable() {
      @Override public void run() {
          new Handler().post(new Runnable() {
              @Override public void run() {
                    MLog.i("Handler in " + Thread.currentThread().getName());
              }
          });
      }
  }).start();複製程式碼

• 答案前面提到了是不能，執行上面的程式碼會出現 java.lang.RuntimeException: Can`t create handler inside thread that has not called Looper.prepare() 這個異常，異常提示我們，不能再沒有呼叫 Looper.prepare() 的執行緒中建立 Handler。

• 簡單修改下程式碼就可以了，給執行緒準備好 Looper

  new Thread(new Runnable() {
      @Override public void run() {
          // 準備一個 Looper，Looper 建立時對應的 MessageQueue 也會被建立
          Looper.prepare();
          // 建立 Handler 並 post 一個 Message 到 MessageQueue
          new Handler().post(new Runnable() {
              @Override public void run() {
                    MLog.i("Handler in " + Thread.currentThread().getName());
              }
          });
          // Looper 開始不斷的從 MessageQueue 取出訊息並再次交給 Handler 執行
          // 此時 Lopper 進入到一個無限迴圈中，後面的程式碼都不會被執行
          Looper.loop();
      }
  }).start();複製程式碼

• 上面的操作 Android 都幫我們封裝好了，正是 HandlerThread 這個類。

HandlerThread 的簡單使用

// 1. 建立 HandlerThread
handlerThread = new HandlerThread("myHandlerThread") {
    // onLooperPrepared 這個方法子執行緒執行，由執行緒的 run 方法呼叫，可以在裡面直接建立 Handler
    @Override protected void onLooperPrepared() {
        super.onLooperPrepared();
        new Handler().post(new Runnable() {
            @Override public void run() {
                // 注意：Handler 在子執行緒建立，這個方法也會執行在子執行緒，不可以更新 UI
                  MLog.i("Handler in " + Thread.currentThread().getName());
            }
        });
    }
};

// 2. 準備 HandlerThread 的 Looper 並呼叫 onLooperPrepared
handlerThread.start();


// 3. 退出
@Override public void onDestroy() {
    super.onDestroy();
    handlerThread.quit();
}

// 也可以這樣用
// 1. 建立 HandlerThread 並準備 Looper
handlerThread = new HandlerThread("myHandlerThread");
handlerThread.start();

// 2. 建立 Handler 並繫結 handlerThread 的 Looper
new Handler(handlerThread.getLooper()).post(new Runnable() {
    @Override public void run() {
          // 注意：Handler 繫結了子執行緒的 Looper，這個方法也會執行在子執行緒，不可以更新 UI
          MLog.i("Handler in " + Thread.currentThread().getName());
    }
});

// 3. 退出
@Override public void onDestroy() {
    super.onDestroy();
    handlerThread.quit();
}複製程式碼

HandlerThread 原始碼解讀

• HandlerThread 繼承了 Thread，本質是一個擁有 Looper 的執行緒，因此在 HandlerThread 我們可以直接使用 Handler。

• 構造方法

  public HandlerThread(String name) {
      super(name);
      mPriority = Process.THREAD_PRIORITY_DEFAULT;
  }
  
  // 傳入執行緒的名稱和優先順序
  // 注意 priority 的值必須來自 android.os.Process 不能來自 java.lang.Thread
  public HandlerThread(String name, int priority) {
      super(name);
      mPriority = priority;
  }複製程式碼

• run 方法：建立子執行緒的 Looper

  @Override
  public void run() {
      mTid = Process.myTid();
      // 準備一個 Looper
      Looper.prepare();
      synchronized (this) {
          // 獲取 Looper
          mLooper = Looper.myLooper();
          // Looper 獲取成功後，喚醒 getLooper 的 wait
          notifyAll();
      }
      Process.setThreadPriority(mPriority);
      // Looper 準備好的回撥，在這個方法裡可以使用 Handler 了
      onLooperPrepared();
      // Looper 開始迴圈取訊息
      Looper.loop();
      mTid = -1;
  }複製程式碼

• getLooper 方法：獲取子執行緒的 Looper

  public Looper getLooper() {
      // 執行緒沒有開始或者死亡，返回 null
        if (!isAlive()) {
            return null;
      }
  
      // If the thread has been started, wait until the looper has been created.
      // Looper 的建立時在子執行緒完成的，而 getLooper 可能會在主執行緒呼叫
      // 當 Looper 沒有建立完成時，使用 wait 阻塞等待
      // 上面在 Looper 建立好後會 notifyAll 來喚醒 wait
       synchronized(this) {
          while (isAlive() && mLooper == null) {
              try {
                    wait();
              } catch (InterruptedException e) {
              }
          }
      }
      return mLooper;
  }複製程式碼

• quit 和 quitSafely ：結束 Looper 的執行

  // quit
  quit() -> looper.quit() -> mQueue.quit(false);
  // quitSafely 
  quitSafely() -> looper.quitSafely() -> mQueue.quit(true);
  
  // 這兩個方法最終都會呼叫到 MessageQueue 的 void quit(boolean safe) 方法
  // 前者會直接移除 MessageQueue 中的所有訊息，然後終止 MessageQueue
  // 後者會將 MessageQueue 中已有訊息處理完成後（不再接收新訊息）終止 MessageQueue複製程式碼

  六.參考文章

  • Android API 25 原始碼
  • Android訊息機制1-Handler(Java層)