深刻淺出，Handler機制外科手術式的剖析（ThreadLocal,Looper,MessageQueen,Message）（上）

時間 2019-11-15

標籤深刻 handler 機制外科手術剖析 threadlocal looper messagequeen message 欄目 Java 简体版

原文原文鏈接

爲何會有handler機制?java

在Android中，全部的UI控件都是運行在主線程中的，若是咱們從子線程訪問UI，系統會報異常。爲何不容許子線程訪問UI呢？由於Android的UI控件不是線程安全的，爲了防止UI控件處於不可控的狀態，就禁止了。主線程是不容許作任何的網絡請求的，那麼請求回來的數據如何同步到UI呢。因此爲了方便線程間通信，就產生了Handler機制，目的就是方便數據在線程間傳遞切換。而更新UI是咱們用的最多見的。算法

先來看一段代碼：數組

private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
// TODO: 9/7/17 do what you wanna
}
};

這個是典型的handler用法，咱們在使用的時候通常都在主線程初始化Handler，那麼有沒有可能在子線程建立handler呢?答案是能夠的，可是若是直接在子線程建立Handler，會報異常：安全

RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");
1
說的很清楚，須要咱們在子線程初始化Looper，經過Looper.prepare();那麼這個Looper是個什麼？它和handler是什麼關係呢？別急，聽我細細道來。網絡

在說Looper以前，先說一下MessageQueen，顧名思義他是一個消息隊列，遵循的是先進先出的原則，可是他的內部不是一個隊列的形式，而是以單鏈表的數據結構來實現的，單鏈表的優點就不用說了吧，插入和刪除的速度相對快。分別對應的是enqueueMessage和next方法。可是他不處理消息，而Looper就是負責處理消息的。數據結構

Looper能夠說是handler的核心類，他是連接MessageQueen和handler的媒介，它開啓後，會無限循環的去MessageQueen中獲取消息，而後交給Handler處理。在初始化Handler以前，必須先初始化Looper，不然就會報上邊的異常，Looper是和線程綁定的，每個線程，只有一個Looper。這一點咱們從Looper的靜態初始化方法中也能夠看出來：less

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

if語句的判斷就是判斷是否有當前thread的Looper，若是有就報異常。咱們注意到，他的判斷依據是sThreadLocal，這是一個ThreadLocal實例。這是一個重要的線程工具類，下邊咱們詳細講一下。
ThreadLocalide

ThreadLocal是java裏邊一個線程數據存儲類，他並非一個Thread，其實做用很是簡單，就是每個使用該變量的線程，都提供一個變量值的副本，每個線程能夠獨立的改變本身的副本，而不和其餘線程的副本衝突。當某些數據是以線程爲做用域而且不一樣線程有不一樣的數據副本的時候，能夠考慮用ThreadLocal，很明顯Looper的做用域就是當前線程，因此很是適合了。經過下邊的下例子，簡單展現下ThreadLocal的特色和用法：工具

public static void main(String[] args){
final ThreadLocal<String> mThreadLocal = new ThreadLocal<String>();
mThreadLocal.set("main");
new Thread("Thread-1") {
public void run() {
mThreadLocal.set(Thread.currentThread().getName());
System.out.println("currentThread:"+Thread.currentThread().getName()+","+mThreadLocal.get());
};
}.start();
System.out.println("currentThread:"+Thread.currentThread().getName()+","+mThreadLocal.get());
}

首先我初始化了一個ThreadLocal的變量mThreadLocal,而後在主線程調用set方法，放入字符串」main「，而後開啓一個子線程，放入子線程的名字，而後分別在子線程和主線程打印get方法獲取的數據，打印結果以下：oop

currentThread:main,main
currentThread:Thread-1,Thread-1

從日誌中咱們能夠看出來，儘管塞數據的時候調用的都是同一個ThreadLocal，可是在不一樣的線程獲取到的數據是不同的。是否是很厲害，可是到底他是如何實現不一樣的線程有不一樣的副本的呢，咱們來看一下它的set方法的源碼：

public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}

從set方法中咱們能夠看到，經過getMap拿到一個ThreadLocalMap對象，而後經過ThreadLocalMap的set方法設置進去，若是這個ThreadLocalMap對象爲null，則執行createMap方法。

從getMap的方法內容咱們能夠看出，他返回的Thread內部的一個成員變量：ThreadLocal.ThreadLocalMap。那麼這個ThreadLocalMap就是數據存儲的關鍵，他是一個內部靜態類，咱們看一下new ThreadLocalMap（this, firstValue）具體作了什麼：

static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;

Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}

ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}

table是一個數組，Entry是ThreadLocalMap的靜態內部類，繼承自WeakReference並以ThreadLocal做爲key，ThreadLocal的泛型實例做爲value。在new ThreadLocalMap的時候，把key和value存入Entry，而後經過必定的算法(算法的具體內容不在分析，有興趣的兄弟能夠本身看看)，把Entry放入數組。接着讓咱們來看下ThreadLocalMap的set(ThreadLocal,Object)方法：

private void set(ThreadLocal key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);

for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();

if (k == key) {
e.value = value;
return;
}

if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

能夠看出它內部是開啓一個for循環，來遍歷數組table，當Entry不爲null的時候，拿到Entry裏邊的value而後替換掉。到這裏咱們算搞明白了ThreadLocal和ThreadLocalMap的關係，以及他們的建立和set方法。

接下來咱們看看ThreadLocal的get方法：

public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}

private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}

protected T initialValue() {
return null;
}

搞明白了剛纔的內容再看這些應該很容易了，代碼邏輯也是比較清晰的，經過ThreadLocalMap拿到Entry，而後拿到Entry的value。值得注意的是，initialValue()直接返回null，因此沒有在相應的線程調用ThreadLocal.set的時候，那麼咱們經過get拿到的就是null。

經過分析源碼咱們能夠得出，ThreadLocal的get和set方法依賴於ThreadLocalMap對象，而ThreadLocalMap對象依賴於Thread被建立，因此不一樣的線程中訪問的數據是不同的。理解了這些，咱們再去理解Looper就很是簡單了。
Looper

Looper是一個輪訓器，他會不斷地去MessageQueen中查看是否有新消息，若是有就當即處理。Looper有如下幾個原則：
1.Handler的建立依賴於對應線程的Looper；
2.一個線程只能有一個Looper，不然會出異常；

前邊咱們講了，在子線程初始化Handler，會報RunTimeException，正確的建立方式以下：

new Thread(){
@Override
public void run() {
Looper.prepare();
Handler threadHandler = new Handler();
Looper.loop();
}
}.start();

Looper.prepare()方法作了什麼，下邊咱們看一下源碼：

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

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));
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}

代碼中有一個成員變量sThreadLocal，他就是一個ThreadLocal實例，裏邊的泛型是Looper，剛纔咱們分析完ThreadLocal，因此很容易咱們就能知道，handler機制是經過這個sThreadLocal來保有當前線程的Looper的。從代碼上咱們能看出來，Looper在prepare的時候，會經過sThreadLocal拿到當前線程的looper，若是不爲null，就報異常，若是爲null，就new一個Looper，塞到sThreadLocal中。

那麼你可能會有一個疑問，爲何主線程不須要執行prepare方法呢？其實，主線程也執行了初始化方法，只不過不是prepare，而是prepareMainLooper方法，這個是專門爲主線程提供的建立Looper的方法。

public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}

從代碼上能夠看出，他也執行了prepare，本質上也是同樣的。
prepare以後，Looper並不會去執行任何操做，只有調用了Looper.loop()方法以後，消息循環系統纔算生效。loop()方法是Looper的主要方法，咱們具體來看一下：

public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;

// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();

for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}

// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}

final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}

if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}

// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}

msg.recycleUnchecked();
}
}
代碼邏輯也是比較清晰的，首先會作一個校驗，檢查當前線程是否有初始化Looper，而後會開啓一個無條件的for循環，不斷地從MessageQueen中獲取消息，若是MessageQueen的next()返回null，則終止方法。message的next()方法是一個阻塞操做，當沒有消息的時候，next方法會阻塞，這也就致使loop方法阻塞。若是從MessageQueen中拿到了message，那麼會經過message調用target的dispatchMessage(Message)。這個target其實就是Handler，一會講Handler的時候咱們會講到。這樣就成功的把消息切換到了指定的線程中去執行，由於dispatchMessage是在建立Handler時候所使用的Looper執行的。

Looper還提供了退出的方法：quit()和quitSafely();他們倆執行的都是同一個方法，都是MessageQueen中的quit(boolean),可是傳入的參數不同。quit會直接退出looper，可是quitSafely只是設定了一個標記，而後把消息隊列的消息處理完畢後才安全退出。quit以後，handler發送消息會失敗，send方法會返回false。在子線程中，執行完全部的handler回調以後應該調用quit方法來終止Looper，不然這個線程會一直處於等待狀態，不能被gc回收。

第一部分就先剖析到這裏，還有一半放在第二篇博客講。