一個執行緒可以有幾個Looper？幾個Handler？從Looper.prepare()來看看關於Looper的一些問題

SillyMonkey發表於2019-04-01
執行緒OOP

前言

之前我有篇文章裡面寫到了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()開啟迴圈取訊息

衍生問題

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

這個問題在剛才已經探討了，只能有一個，不然呼叫Looper.prepare()會丟擲執行時異常，提示“Only one Looper may be created per thread”

一個執行緒可以有幾個Handler

可以建立無數個Handler，但是他們使用的訊息佇列都是同一個，也就是同一個Looper

同一個Looper是怎麼區分不同的Handler的，換句話說，不同的Handler是怎麼做到處理自己發出的訊息的

這個問題就要來到Handler的sendMessage方法裡面了，具體的流程這裡不詳說了，最後來到了這個方法

Handler.enqueueMessage

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
複製程式碼

可以看到這一句msg.target = this;，這裡就是將當前的Handler賦值給Message物件，這樣在處理訊息的時候通過msg.target就可以區分開不同的Handler了。處理的方法在Looper.loop中：

Looper.loop()

...
msg.target.dispatchMessage(msg);
...
複製程式碼

順便提一句，在Message的obtain的各種過載方法裡面也有對target的賦值

相關文章