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