一個線程能夠有幾個Looper？幾個Handler？從Looper.prepare()來看看關於Looper的一些問題

前言

以前我有篇文章裏面寫到了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的賦值