一個執行緒可以有幾個Looper？幾個Handler？

執行緒安卓開發 · 發表 2019-02-18 11:37:03

摘要：前言之前我有篇文章裡面寫到了Android的訊息機制，Handler傳送訊息的一些原理。連結如下：從Handler.post(Runnable r)再一次梳理Android的訊息機制（以及handler的記憶體洩露）在訊息機制裡...

前言

之前我有篇文章裡面寫到了Android的訊息機制，Handler傳送訊息的一些原理。連結如下：

從Handler.post(Runnable r)再一次梳理Android的訊息機制（以及handler的記憶體洩露）

在訊息機制裡面，有一個非常重要的東西，那就是Looper ，Looper的作用主要是從訊息佇列裡面取出訊息交給Handler處理 ，不過不僅限於此，在這裡面還有很多東西值得我們去原始碼看一看：

1.從Looper.prepare()開始

要在一個執行緒裡面處理訊息，程式碼如下：

class LooperThread extends Thread
{
public Handler mHandler;
public void run() 
{
Looper.prepare();
mHandler = new Handler() 
{
public void handleMessage(Message msg) 
{
// process incoming messages here
}
};
Looper.loop();
}

首先就必須要先呼叫Looper.prepare() ，那這個方法做了些什麼呢：

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

程式碼其實只有關鍵性的一句，就是sThreadLocal.set(new Looper(quitAllowed)) ，首先來看看sThreadLocal

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

ThreadLocal ：代表了一個執行緒區域性的變數，每條執行緒都只能看到自己的值，並不會意識到其它的執行緒中也存在該變數。

在這裡ThreadLocal 的作用是保證了每個執行緒都有各自的Looper

上面的判斷也說明了一個問題：一個執行緒只能有一個Looper

接下來看看建立Looper例項的方法new Looper(quitAllowed) ：

final MessageQueue mQueue;
final Thread mThread;

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

在構造方法裡，初始化了MessageQueue 和代表當前執行緒的屬性mThread ，關於MessageQueue 可以看看文章開頭的連結，裡面有詳細的程式碼解析，這裡就不贅述了。

呼叫Looper.prepare()其實就是利用ThreadLocal為當前的執行緒建立了一個獨立的Looper，這其中包含了一個訊息佇列

2.建立Handler->new Handler()

在為當前執行緒建立了Looper之後，就可以建立Handler來處理訊息了，這裡可以解決我們一個疑問：

Handler是怎麼跟Looper關聯上的？

//全域性變數
final Looper mLooper;
final MessageQueue mQueue;

public Handler(Callback callback, boolean async) {
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());
}
}

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

在Handler中有兩個全域性變數mLooper 和mQueue 代表當前Handler關聯的Looper和訊息佇列，並在建構函式中進行了初始化，重要的就是呼叫了：Looper.myLooper() ：

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

其實還是呼叫的執行緒區域性變數sThreadLocal ，獲取當前執行緒的Looper，這裡需要注意的是，如果當前執行緒沒有關聯的Looper，這個方法會返回null。

注意：Handler在哪個執行緒建立的，就跟哪個執行緒的Looper關聯，也可以在Handler的構造方法中傳入指定的Looper

3.Looper.loop()迴圈讀取訊息

這個方法也在之前的文章裡講到過，核心就是一個死迴圈，從MessageQueue裡面取訊息出來交給Handler來處理。

執行緒訊息機制的原理

看了原始碼之後，我們就知道了為啥線上程中需要處理訊息，必須要經過以上三個步驟，且順序不可更改

1.Looper.prepare()：為當前執行緒準備訊息佇列

2.Handler預設構造方法跟當前執行緒中的Looper產生關聯

3.Looper.loop()開啟迴圈取訊息

衍生問題