前言
Handler機(jī)制引出ThreadLocal
- 關(guān)于ThreadLocal的分析，首先得從Android的消息機(jī)制談起，可能我們最先想到的就是Android消息機(jī)制的上層接口Handler
- 為了避免ANR，我們會通常把耗時操作放在子線程里面去執(zhí)行，因?yàn)樽泳€程不能更新UI，所以當(dāng)子線程需要更新UI的時候就需要借助到Android的消息機(jī)制，也就是Handler機(jī)制了
關(guān)于Handler的原理，不是本文剖析的重點(diǎn)，這里僅給出一些相關(guān)結(jié)論，同時引出今天的主角ThreadLocal
- 如果handler綁定的是當(dāng)前線程的looper，那么處理過程也是運(yùn)行在當(dāng)前線程（主線程使用默認(rèn)構(gòu)造函數(shù)創(chuàng)建的Handler默認(rèn)綁定的是主線程的looper）
- 一個Looper對應(yīng)一個MessageQueue
- 一個線程對應(yīng)一個Looper
- 一個Looper可以對應(yīng)多個Handler
- 線程是默認(rèn)沒有Looper的，線程需要通過Looper.prepare()、綁定Handler到Looper對象、Looper.loop()來建立消息循環(huán)
- 主線程（UI線程），也就是ActivityThread，在被創(chuàng)建的時候就會初始化Looper，所以主線程中可以默認(rèn)使用Handler
- 可以通過Looper的quitSafely()或者quit()方法終結(jié)消息循環(huán)，quitSafely相比于quit方法安全之處在于清空消息之前會派發(fā)所有的非延遲消息。
- 不確定當(dāng)前線程時，更新UI時盡量調(diào)用post方法
如何保證一個線程對應(yīng)一個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>();
....//省略
}
分析
案例展示及運(yùn)行結(jié)果
這里先給出ThreadLocal和InheritableThreadLocal的簡單實(shí)用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");
}
}
運(yùn)行結(jié)果：
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 ******************************************
如果這個時候你對運(yùn)行結(jié)果有疑問 或者說 「我擦」怎么又突然冒出來一個InheritableThreadLocal，那么請繼續(xù)往下看
ThreadLocal類結(jié)構(gòu)預(yù)覽
當(dāng)然，我們肯定要先從ThreadLocal開始說起：
先從大體上看一下，可以發(fā)現(xiàn)，Java和Android中ThreadLocal的類結(jié)構(gòu)（包括部分細(xì)節(jié)）還是有一些區(qū)別的，不過Android中的實(shí)現(xiàn)方式越來越貼近Java版
第一張圖為jdk1.8.0_131中ThreadLocal的類結(jié)構(gòu)：
第二張圖為android-25中ThreadLocal的類結(jié)構(gòu)：
ThreadLocal探秘
這里主要以Android-25（Android7.1.1）的源碼為基礎(chǔ)進(jìn)行分析，其實(shí)幾乎和Java版本的源碼一致
首先澄清一下對ThreadLocal的錯誤認(rèn)知：
ThreadLocal為解決多線程程序的并發(fā)問題提供了一種新的思路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類用來提供線程內(nèi)部的局部變量。這種變量在多線程環(huán)境下訪問(通過get或set方法訪問)時能保證各個線程里的變量相對獨(dú)立于其他線程內(nèi)的變量。ThreadLocal實(shí)例通常來說都是private static類型的，用于關(guān)聯(lián)線程和線程的上下文。
可以這么總結(jié)：ThreadLocal的作用是提供線程內(nèi)的局部變量，這種變量在線程的生命周期內(nèi)起作用，減少同一個線程內(nèi)多個函數(shù)或者組件之間一些公共變量的傳遞的復(fù)雜度。
有時候大家會拿同步機(jī)制（如synchronized）和ThreadLocal做對比，怎么說才能不引起誤解那？
可以這么理解：
對于多線程資源共享的問題，前者僅提供一份變量，讓不同的線程排隊(duì)訪問，而后者為每一個線程都提供了一份變量，因此可以同時訪問而互不影響。但是ThreadLocal卻并不是為了解決并發(fā)或者多線程資源共享而設(shè)計的
所以ThreadLocal既不是為了解決共享多線程的訪問問題，更不是為了解決線程同步問題，ThreadLocal的設(shè)計初衷就是為了提供線程內(nèi)部的局部變量，方便在本線程內(nèi)隨時隨地的讀取，并且與其他線程隔離。
ThreadLocal的應(yīng)用場景：
- 當(dāng)某些數(shù)據(jù)是以線程為作用域并且不同線程具有不同的數(shù)據(jù)副本的時候
如：屬性動畫為每個線程設(shè)置AnimationHandler、Android的Handler消息機(jī)制中通過ThreadLocal實(shí)現(xiàn)Looper在線程中的存取、EventBus獲取當(dāng)前線程的PostingThreadState對象或者即將被分發(fā)的事件隊(duì)列或者當(dāng)前線程是否正在進(jìn)行事件分發(fā)的布爾值
- 復(fù)雜邏輯下的對象傳遞
使用參數(shù)傳遞的話：當(dāng)函數(shù)調(diào)用棧更深時，設(shè)計會很糟糕，為每一個線程定義一個靜態(tài)變量監(jiān)聽器，如果是多線程的話，一個線程就需要定義一個靜態(tài)變量，無法擴(kuò)展，這時候使用ThreadLocal就可以解決問題。
ThreadLocal源碼解讀
構(gòu)造函數(shù)：
public ThreadLocal() {
}
創(chuàng)建一個線程的本地變量
initialValue函數(shù)：
protected T initialValue() {
return null;
}
該函數(shù)在調(diào)用get函數(shù)的時候會第一次調(diào)用，但是如果一開始就調(diào)用了set函數(shù)，則該函數(shù)不會被調(diào)用。通常該函數(shù)只會被調(diào)用一次，除非手動調(diào)用了remove函數(shù)之后又調(diào)用get函數(shù)，這種情況下，get函數(shù)中還是會調(diào)用initialValue函數(shù)。該函數(shù)是protected類型的，很顯然是建議在子類重載該函數(shù)的，所以通常該函數(shù)都會以匿名內(nèi)部類的形式被重載，以指定初始值，比如
public class TestThreadLocal {
private static final ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return Integer.valueOf(1);
}
};
}
get函數(shù)：
該函數(shù)用來獲取與當(dāng)前線程關(guān)聯(lián)的ThreadLocal的值,如果當(dāng)前線程沒有該ThreadLocal的值，則調(diào)用initialValue函數(shù)獲取初始值返回
public T get() {
//1、首先獲取當(dāng)前線程
Thread t = Thread.currentThread();
//2、根據(jù)當(dāng)前線程獲取一個map
ThreadLocalMap map = getMap(t);
//3、如果獲取的map不為空，則在map中以ThreadLocal的引用作為key來在Map中獲取對應(yīng)的Entry e，否則轉(zhuǎn)到5
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
//4、如果e不為null，則返回e.value，否則轉(zhuǎn)到5
if (e != null)
return (T)e.value;
}
//5、map為空或者e為空，則通過initialValue函數(shù)獲取初始值value，然后用ThreadLocal的引用和value作為firstKey和firstValue創(chuàng)建一個新的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函數(shù)：
set函數(shù)用來設(shè)置當(dāng)前線程的該ThreadLocal的值,設(shè)置當(dāng)前線程的ThreadLocal的值為value
public void set(T value) {
//1、首先獲取當(dāng)前線程
Thread t = Thread.currentThread();
//2、根據(jù)當(dāng)前線程獲取一個map
ThreadLocalMap map = getMap(t);
if (map != null)
//3、map不為空，則把鍵值對保存到map中
map.set(this, value);
//4、如果map為空（第一次調(diào)用的時候map值為null），則去創(chuàng)建一個ThreadLocalMap對象并賦值給map，并把鍵值對保存到map中。
else
createMap(t, value);
}
remove函數(shù)：
remove函數(shù)用來將當(dāng)前線程的ThreadLocal綁定的值刪除,在某些情況下需要手動調(diào)用該函數(shù)，防止內(nèi)存泄露。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
ThreadLocalMap：
可以看成一個HashMap，但是它本身具體的實(shí)現(xiàn)卻與java.util.Map沾不上一點(diǎn)關(guān)系。只是內(nèi)部的實(shí)現(xiàn)跟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;
}
}
...//省略
}
大致類結(jié)構(gòu)如下圖所示：
ThreadLocalMap中定義了Entry數(shù)組實(shí)例table，用于存儲Entry。相當(dāng)于使用一個數(shù)組維護(hù)一張哈希表，負(fù)載因子是最大容量的2/3
private Entry[] table;
關(guān)于ThreadLocalMap重要函數(shù)的分析會結(jié)合下一節(jié)ThreadLocal內(nèi)存泄漏的問題一并討論
PS：Android早期版本，這部分的數(shù)據(jù)結(jié)構(gòu)是通過Values實(shí)現(xiàn)的，Values中也有一個table的成員變量，table是一個Object數(shù)組，也是以類似map的方式來存儲的。偶數(shù)單元存儲的是key，key的下一個單元存儲的是對應(yīng)的value，所以每存儲一個元素，需要兩個單元，所以容量一定是2的倍數(shù)。這里的key存儲的也是ThreadLocal實(shí)例的弱引用
ThreadLocal內(nèi)存泄漏的問題
ThreadLocal里面使用了一個存在弱引用的map,當(dāng)釋放掉ThreadLocal的強(qiáng)引用以后,map里面的value卻沒有被回收.而這塊value永遠(yuǎn)不會被訪問到了. 所以存在著內(nèi)存泄露. 最好的做法是將調(diào)用ThreadLocal的remove方法.
在ThreadLocal的生命周期中,都存在這些引用.
看下圖(來源參考): 實(shí)線代表強(qiáng)引用,虛線代表弱引用.
- 每個thread中都存在一個map, map的類型是ThreadLocal.ThreadLocalMap. Map中的key為一個ThreadLocal實(shí)例. 這個Map的確使用了弱引用,不過弱引用只是針對key. 每個key都弱引用指向ThreadLocal. 當(dāng)把ThreadLocal實(shí)例置為null以后,沒有任何強(qiáng)引用指向ThreadLocal實(shí)例,所以ThreadLocal將會被gc回收. 但是,我們的value卻不能回收,因?yàn)榇嬖谝粭l從current thread連接過來的強(qiáng)引用. 只有當(dāng)前thread結(jié)束以后, current thread就不會存在棧中,強(qiáng)引用斷開, Current Thread, Map, value將全部被GC回收.
- 所以得出一個結(jié)論就是只要這個線程對象被gc回收，就不會出現(xiàn)內(nèi)存泄露，但在ThreadLocal設(shè)為null和線程結(jié)束這段時間不會被回收的，就發(fā)生了我們認(rèn)為的內(nèi)存泄露。其實(shí)這是一個對概念理解的不一致，也沒什么好爭論的。最要命的是線程對象不被回收的情況，這就發(fā)生了真正意義上的內(nèi)存泄露。比如使用線程池的時候，線程結(jié)束是不會銷毀的，會再次使用的。就可能出現(xiàn)內(nèi)存泄露。
- 為了最小化減少內(nèi)存泄露的可能性和影響，(設(shè)計中加上了一些防護(hù)措施)在ThreadLocal的get,set的時候都會清除線程Map里所有key為null的value。所以最怕的情況就是，threadLocal對象設(shè)null了，開始發(fā)生“內(nèi)存泄露”，然后使用線程池，這個線程結(jié)束，線程放回線程池中不銷毀，這個線程一直不被使用，或者分配使用了又不再調(diào)用get,set方法，那么這個期間就會發(fā)生真正的內(nèi)存泄露。
getEntry函數(shù)：
首先從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函數(shù)：
這個過程中遇到的key為null的Entry都會被擦除（Entry內(nèi)的value也就沒有強(qiáng)引用鏈，自然會被回收）
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);
//繼續(xù)向下一個位置查詢
e = tab[i];
}
return null;
}
set函數(shù)：
set操作也有類似的思想，將key為null的這些Entry都刪除，防止內(nèi)存泄露
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();
}
小結(jié)：
- 雖然源碼中對內(nèi)存泄漏做了很好的防護(hù)作用，但是很多情況下還是需要手動調(diào)用ThreadLocal的remove函數(shù)，手動刪除不再需要的ThreadLocal，防止內(nèi)存泄露。
- 所以JDK建議將ThreadLocal變量定義成private static的，這樣的話ThreadLocal的生命周期就更長，由于一直存在ThreadLocal的強(qiáng)引用，所以ThreadLocal也就不會被回收，也就能保證任何時候都能根據(jù)ThreadLocal的弱引用訪問到Entry的value值，然后remove它，防止內(nèi)存泄露。
InheritableThreadLocal與ThreadLocal的區(qū)別
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);
}
}
其實(shí)就是重寫了3個方法
- InheritableThreadLocal的get()方法會調(diào)用getMap(t),而這時返回的是inheritableThreadLocals(Thread的一個成員變量)
- 父線程往子線程中傳遞值是在Thread thread = new Thread()的時候，然后調(diào)用線程內(nèi)部的init方法進(jìn)行處理，最終就是不斷的把當(dāng)前線程的inheritableThreadLocals值復(fù)制到我們新創(chuàng)建的線程中的inheritableThreadLocals 中
- 主要面對的是線程中再創(chuàng)建線程的場景，類似開篇舉的例子，而對于子線程之間的傳遞或者線程池中得到父線程的值則不可行（這部分沒有深入研究）
總結(jié)
現(xiàn)在回過頭來分析開篇的例子：
- 第一次打?。鹤泳€程中的ThreadLocal沒有賦值，所以為null，而子線程中的InheritableThreadLocal卻可以獲取到父線程中的值CONSTANT_01
- 第二次打印：子線程ThreadLocal和InheritableThreadLocal同時重新賦值CONSTANT_02，所以打印出的結(jié)果都為CONSTANT_02
- 第三次打?。夯氐街骶€程，主線程和子線程都是維護(hù)自己的副本，所以子線程賦值CONSTANT_02并不會對主線程有任何影響，所以主線程打印出的結(jié)果依舊都是CONSTANT_01
其它
- 我的CSDN博客地址：http://blog.csdn.net/s003603u
- 我的GitHub地址：https://github.com/soulrelay
- 我的簡書地址：http://www.lxweimin.com/u/514ca03bbc17
- 我的掘金地址：https://juejin.im/user/56f3d9d1816dfa00522b8f20
- 我的個人站點(diǎn)： http://sushuai.tech/
