前言
Handler機制引出ThreadLocal
- 關于ThreadLocal的分析，首先得從Android的消息機制談起，可能我們最先想到的就是Android消息機制的上層接口Handler
- 為了避免ANR，我們會通常把耗時操作放在子線程里面去執行，因為子線程不能更新UI，所以當子線程需要更新UI的時候就需要借助到Android的消息機制，也就是Handler機制了
關于Handler的原理，不是本文剖析的重點，這里僅給出一些相關結論，同時引出今天的主角ThreadLocal
- 如果handler綁定的是當前線程的looper，那么處理過程也是運行在當前線程（主線程使用默認構造函數創建的Handler默認綁定的是主線程的looper）
- 一個Looper對應一個MessageQueue
- 一個線程對應一個Looper
- 一個Looper可以對應多個Handler
- 線程是默認沒有Looper的，線程需要通過Looper.prepare()、綁定Handler到Looper對象、Looper.loop()來建立消息循環
- 主線程（UI線程），也就是ActivityThread，在被創建的時候就會初始化Looper，所以主線程中可以默認使用Handler
- 可以通過Looper的quitSafely()或者quit()方法終結消息循環，quitSafely相比于quit方法安全之處在于清空消息之前會派發所有的非延遲消息。
- 不確定當前線程時，更新UI時盡量調用post方法
如何保證一個線程對應一個Looper，同時各個線程之間的Looper互不干擾就引出了接下來要討論的ThreadLocal
public final class Looper {
private static final String TAG = "Looper";
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
....//省略
}
分析
案例展示及運行結果
這里先給出ThreadLocal和InheritableThreadLocal的簡單實用demo
public class ThreadLocalTest {
static final String CONSTANT_01 = "CONSTANT_01";
static final String CONSTANT_02 = "CONSTANT_02";
public static void main(String[] args) throws InterruptedException {
ThreadLocal<String> threadLocal = new ThreadLocal<String>();
threadLocal.set(CONSTANT_01);
InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<String>();
inheritableThreadLocal.set(CONSTANT_01);
Thread thread_1 = new TestThread(threadLocal, inheritableThreadLocal);
thread_1.setName("thread_01");
thread_1.start();
thread_1.join();
System.out.println(" " + Thread.currentThread().getName() + " ******************************************");
System.out.println(" " + Thread.currentThread().getName() + " \tThreadLocal: " + threadLocal.get());
System.out.println(" " + Thread.currentThread().getName() + " \tInheritableThreadLocal: " + inheritableThreadLocal.get());
System.out.println(" " + Thread.currentThread().getName() + " ******************************************");
}
}
class TestThread extends Thread {
ThreadLocal<String> threadLocal;
InheritableThreadLocal<String> inheritableThreadLocal;
public TestThread(ThreadLocal<String> threadLocal, InheritableThreadLocal<String> inheritableThreadLocal) {
super();
this.threadLocal = threadLocal;
this.inheritableThreadLocal = inheritableThreadLocal;
}
public void run() {
System.out.println(Thread.currentThread().getName() + "******************************************");
System.out.println(Thread.currentThread().getName() + "\tThreadLocal: " + threadLocal.get());
System.out.println(Thread.currentThread().getName() + "\tInheritableThreadLocal: " + inheritableThreadLocal.get());
System.out.println(Thread.currentThread().getName() + "******************************************\n");
threadLocal.set(ThreadLocalTest.CONSTANT_02);
inheritableThreadLocal.set(ThreadLocalTest.CONSTANT_02);
System.out.println(Thread.currentThread().getName() + "*************(Reset Value)****************");
System.out.println(Thread.currentThread().getName() + "\tThreadLocal: " + threadLocal.get());
System.out.println(Thread.currentThread().getName() + "\tInheritableThreadLocal: " + inheritableThreadLocal.get());
System.out.println(Thread.currentThread().getName() + "*************(Reset Value)****************\n");
}
}
運行結果：
thread_01******************************************
thread_01 ThreadLocal: null
thread_01 InheritableThreadLocal: CONSTANT_01
thread_01******************************************
thread_01*************(Reset Value)****************
thread_01 ThreadLocal: CONSTANT_02
thread_01 InheritableThreadLocal: CONSTANT_02
thread_01*************(Reset Value)****************
main ******************************************
main ThreadLocal: CONSTANT_01
main InheritableThreadLocal: CONSTANT_01
main ******************************************
如果這個時候你對運行結果有疑問 或者說 「我擦」怎么又突然冒出來一個InheritableThreadLocal，那么請繼續往下看
ThreadLocal類結構預覽
當然，我們肯定要先從ThreadLocal開始說起：
先從大體上看一下，可以發現，Java和Android中ThreadLocal的類結構（包括部分細節）還是有一些區別的，不過Android中的實現方式越來越貼近Java版
第一張圖為jdk1.8.0_131中ThreadLocal的類結構：
第二張圖為android-25中ThreadLocal的類結構：
ThreadLocal探秘
這里主要以Android-25（Android7.1.1）的源碼為基礎進行分析，其實幾乎和Java版本的源碼一致
首先澄清一下對ThreadLocal的錯誤認知：
ThreadLocal為解決多線程程序的并發問題提供了一種新的思路ThreadLocal的目的是為了解決多線程訪問資源時的共享問題
為什么這么說那？
我們看看Android源碼中是如何介紹ThreadLocal的：
This class provides thread-local variables. These variables differ from
their normal counterparts in that each thread that accesses one (via its
<tt>get</tt> or <tt>set</tt> method) has its own, independently initialized copy of the variable. <tt>ThreadLocal</tt> instances are typically private static fields in classes that wish to associate state with a thread (e.g.,a user ID or Transaction ID).
描述的大致意思是這樣：ThreadLocal類用來提供線程內部的局部變量。這種變量在多線程環境下訪問(通過get或set方法訪問)時能保證各個線程里的變量相對獨立于其他線程內的變量。ThreadLocal實例通常來說都是private static類型的，用于關聯線程和線程的上下文。
可以這么總結：ThreadLocal的作用是提供線程內的局部變量，這種變量在線程的生命周期內起作用，減少同一個線程內多個函數或者組件之間一些公共變量的傳遞的復雜度。
有時候大家會拿同步機制（如synchronized）和ThreadLocal做對比，怎么說才能不引起誤解那？
可以這么理解：
對于多線程資源共享的問題，前者僅提供一份變量，讓不同的線程排隊訪問，而后者為每一個線程都提供了一份變量，因此可以同時訪問而互不影響。但是ThreadLocal卻并不是為了解決并發或者多線程資源共享而設計的
所以ThreadLocal既不是為了解決共享多線程的訪問問題，更不是為了解決線程同步問題，ThreadLocal的設計初衷就是為了提供線程內部的局部變量，方便在本線程內隨時隨地的讀取，并且與其他線程隔離。
ThreadLocal的應用場景：
- 當某些數據是以線程為作用域并且不同線程具有不同的數據副本的時候
如：屬性動畫為每個線程設置AnimationHandler、Android的Handler消息機制中通過ThreadLocal實現Looper在線程中的存取、EventBus獲取當前線程的PostingThreadState對象或者即將被分發的事件隊列或者當前線程是否正在進行事件分發的布爾值
- 復雜邏輯下的對象傳遞
使用參數傳遞的話：當函數調用棧更深時，設計會很糟糕，為每一個線程定義一個靜態變量監聽器，如果是多線程的話，一個線程就需要定義一個靜態變量，無法擴展，這時候使用ThreadLocal就可以解決問題。
ThreadLocal源碼解讀
構造函數：
public ThreadLocal() {
}
創建一個線程的本地變量
initialValue函數：
protected T initialValue() {
return null;
}
該函數在調用get函數的時候會第一次調用，但是如果一開始就調用了set函數，則該函數不會被調用。通常該函數只會被調用一次，除非手動調用了remove函數之后又調用get函數，這種情況下，get函數中還是會調用initialValue函數。該函數是protected類型的，很顯然是建議在子類重載該函數的，所以通常該函數都會以匿名內部類的形式被重載，以指定初始值，比如
public class TestThreadLocal {
private static final ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return Integer.valueOf(1);
}
};
}
get函數：
該函數用來獲取與當前線程關聯的ThreadLocal的值,如果當前線程沒有該ThreadLocal的值，則調用initialValue函數獲取初始值返回
public T get() {
//1、首先獲取當前線程
Thread t = Thread.currentThread();
//2、根據當前線程獲取一個map
ThreadLocalMap map = getMap(t);
//3、如果獲取的map不為空，則在map中以ThreadLocal的引用作為key來在Map中獲取對應的Entry e，否則轉到5
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
//4、如果e不為null，則返回e.value，否則轉到5
if (e != null)
return (T)e.value;
}
//5、map為空或者e為空，則通過initialValue函數獲取初始值value，然后用ThreadLocal的引用和value作為firstKey和firstValue創建一個新的map
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
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;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
值得注意的是，上面getMap方法中獲取的threadLocals即是Thread中的一個成員變量
public class Thread implements Runnable {
...//省略
/* ThreadLocal values pertaining to this thread. This map is maintained by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
* InheritableThreadLocal values pertaining to this thread. This map is maintained by the InheritableThreadLocal class.*/
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
...//省略
}
這里的inheritableThreadLocals會在下文分析InheritableThreadLocal涉及到
set函數：
set函數用來設置當前線程的該ThreadLocal的值,設置當前線程的ThreadLocal的值為value
public void set(T value) {
//1、首先獲取當前線程
Thread t = Thread.currentThread();
//2、根據當前線程獲取一個map
ThreadLocalMap map = getMap(t);
if (map != null)
//3、map不為空，則把鍵值對保存到map中
map.set(this, value);
//4、如果map為空（第一次調用的時候map值為null），則去創建一個ThreadLocalMap對象并賦值給map，并把鍵值對保存到map中。
else
createMap(t, value);
}
remove函數：
remove函數用來將當前線程的ThreadLocal綁定的值刪除,在某些情況下需要手動調用該函數，防止內存泄露。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
ThreadLocalMap：
可以看成一個HashMap，但是它本身具體的實現卻與java.util.Map沾不上一點關系。只是內部的實現跟HashMap類似（通過哈希表的方式存儲）。
static class ThreadLocalMap {
static class Entry extend WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
...//省略
}
大致類結構如下圖所示：
ThreadLocalMap中定義了Entry數組實例table，用于存儲Entry。相當于使用一個數組維護一張哈希表，負載因子是最大容量的2/3
private Entry[] table;
關于ThreadLocalMap重要函數的分析會結合下一節ThreadLocal內存泄漏的問題一并討論
PS：Android早期版本，這部分的數據結構是通過Values實現的，Values中也有一個table的成員變量，table是一個Object數組，也是以類似map的方式來存儲的。偶數單元存儲的是key，key的下一個單元存儲的是對應的value，所以每存儲一個元素，需要兩個單元，所以容量一定是2的倍數。這里的key存儲的也是ThreadLocal實例的弱引用
ThreadLocal內存泄漏的問題
ThreadLocal里面使用了一個存在弱引用的map,當釋放掉ThreadLocal的強引用以后,map里面的value卻沒有被回收.而這塊value永遠不會被訪問到了. 所以存在著內存泄露. 最好的做法是將調用ThreadLocal的remove方法.
在ThreadLocal的生命周期中,都存在這些引用.
看下圖(來源參考): 實線代表強引用,虛線代表弱引用.
- 每個thread中都存在一個map, map的類型是ThreadLocal.ThreadLocalMap. Map中的key為一個ThreadLocal實例. 這個Map的確使用了弱引用,不過弱引用只是針對key. 每個key都弱引用指向ThreadLocal. 當把ThreadLocal實例置為null以后,沒有任何強引用指向ThreadLocal實例,所以ThreadLocal將會被gc回收. 但是,我們的value卻不能回收,因為存在一條從current thread連接過來的強引用. 只有當前thread結束以后, current thread就不會存在棧中,強引用斷開, Current Thread, Map, value將全部被GC回收.
- 所以得出一個結論就是只要這個線程對象被gc回收，就不會出現內存泄露，但在ThreadLocal設為null和線程結束這段時間不會被回收的，就發生了我們認為的內存泄露。其實這是一個對概念理解的不一致，也沒什么好爭論的。最要命的是線程對象不被回收的情況，這就發生了真正意義上的內存泄露。比如使用線程池的時候，線程結束是不會銷毀的，會再次使用的。就可能出現內存泄露。
- 為了最小化減少內存泄露的可能性和影響，(設計中加上了一些防護措施)在ThreadLocal的get,set的時候都會清除線程Map里所有key為null的value。所以最怕的情況就是，threadLocal對象設null了，開始發生“內存泄露”，然后使用線程池，這個線程結束，線程放回線程池中不銷毀，這個線程一直不被使用，或者分配使用了又不再調用get,set方法，那么這個期間就會發生真正的內存泄露。
getEntry函數：
首先從ThreadLocal的直接索引位置獲取Entry e，如果e不為null并且key相同則返回e；如果e為null或者key不一致則通過getEntryAfterMiss向下一個位置查詢
private Entry getEntry(ThreadLocal key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
getEntryAfterMiss函數：
這個過程中遇到的key為null的Entry都會被擦除（Entry內的value也就沒有強引用鏈，自然會被回收）
private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal k = e.get();
if (k == key)
//命中
return e;
if (k == null)
//如果key值為null，則擦除該位置的Entry
expungeStaleEntry(i);
else
i = nextIndex(i, len);
//繼續向下一個位置查詢
e = tab[i];
}
return null;
}
set函數：
set操作也有類似的思想，將key為null的這些Entry都刪除，防止內存泄露
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();
}
小結：
- 雖然源碼中對內存泄漏做了很好的防護作用，但是很多情況下還是需要手動調用ThreadLocal的remove函數，手動刪除不再需要的ThreadLocal，防止內存泄露。
- 所以JDK建議將ThreadLocal變量定義成private static的，這樣的話ThreadLocal的生命周期就更長，由于一直存在ThreadLocal的強引用，所以ThreadLocal也就不會被回收，也就能保證任何時候都能根據ThreadLocal的弱引用訪問到Entry的value值，然后remove它，防止內存泄露。
InheritableThreadLocal與ThreadLocal的區別
InheritableThreadLocal比ThreadLocal多一個特性，繼承性，可以從父線程中得到初始值
首先瀏覽下 InheritableThreadLocal 類中有什么東西：
public class InheritableThreadLocal<T> extends ThreadLocal<T> {
protected T childValue(T parentValue) {
return parentValue;
}
ThreadLocalMap getMap(Thread t) {
return t.inheritableThreadLocals;
}
void createMap(Thread t, T firstValue) {
t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
}
}
其實就是重寫了3個方法
- InheritableThreadLocal的get()方法會調用getMap(t),而這時返回的是inheritableThreadLocals(Thread的一個成員變量)
- 父線程往子線程中傳遞值是在Thread thread = new Thread()的時候，然后調用線程內部的init方法進行處理，最終就是不斷的把當前線程的inheritableThreadLocals值復制到我們新創建的線程中的inheritableThreadLocals 中
- 主要面對的是線程中再創建線程的場景，類似開篇舉的例子，而對于子線程之間的傳遞或者線程池中得到父線程的值則不可行（這部分沒有深入研究）
總結
現在回過頭來分析開篇的例子：
- 第一次打印：子線程中的ThreadLocal沒有賦值，所以為null，而子線程中的InheritableThreadLocal卻可以獲取到父線程中的值CONSTANT_01
- 第二次打印：子線程ThreadLocal和InheritableThreadLocal同時重新賦值CONSTANT_02，所以打印出的結果都為CONSTANT_02
- 第三次打印：回到主線程，主線程和子線程都是維護自己的副本，所以子線程賦值CONSTANT_02并不會對主線程有任何影響，所以主線程打印出的結果依舊都是CONSTANT_01
其它
- 我的CSDN博客地址：http://blog.csdn.net/s003603u
- 我的GitHub地址：https://github.com/soulrelay
- 我的簡書地址：http://www.lxweimin.com/u/514ca03bbc17
- 我的掘金地址：https://juejin.im/user/56f3d9d1816dfa00522b8f20
- 我的個人站點： http://sushuai.tech/
