一個(gè)ThreadLocal和面試官大戰(zhàn)30個(gè)回合
開場
杭州某商務(wù)樓里，正發(fā)生著一起求職者和面試官的battle。
面試官：你先自我介紹一下。
安琪拉：面試官你好，我是草叢三婊，最強(qiáng)中單（妲己不服），草地摩托車車手，第21套廣播體操推廣者，火的傳人安琪拉，這是我的簡歷，請過目。
面試官：看你簡歷上寫熟悉多線程編程，熟悉到什么程度？
安琪拉：精通。
對。。。，你沒看錯(cuò)，問就是“精通”，把666打在評論區(qū)。
面試官：
[心想] 莫不是個(gè)憨批，上來就說自己精通，誰把精通掛嘴上，莫不是個(gè)愣頭青嘞！
面試官：那我們開始吧。用過Threadlocal 吧？
安琪拉：用過。
面試官：那你跟我講講 ThreadLocal 在你們項(xiàng)目中的用法吧。
安琪拉：我們項(xiàng)目屬于保密項(xiàng)目，無可奉告，你還是換個(gè)問題吧！
面試官：那說個(gè)不保密的項(xiàng)目，或者你直接告訴我Threadlocal 的實(shí)現(xiàn)原理吧。
正題
安琪拉：show time。。。
安琪拉：舉個(gè)栗子，我們支付寶每秒鐘同時(shí)會(huì)有很多用戶請求，那每個(gè)請求都帶有用戶信息，我們知道通常都是一個(gè)線程處理一個(gè)用戶請求，我們可以把用戶信息丟到Threadlocal里面，讓每個(gè)線程處理自己的用戶信息，線程之間互不干擾。
面試官：等等，問你個(gè)私人問題，為什么從支付寶跑出來面試，受不了PUA了嗎？
安琪拉：PUA我，不存在的，能PUA我的人還沒出生呢！公司食堂吃膩了，想換換口味。
面試官：那你來給我講講Threadlocal是干什么的？
安琪拉：Threadlocal 主要用來做線程變量的隔離，這么說可能不是很直觀。
還是說前面提到的例子，我們程序在處理用戶請求的時(shí)候，通常后端服務(wù)器是有一個(gè)線程池，來一個(gè)請求就交給一個(gè)線程來處理，那為了防止多線程并發(fā)處理請求的時(shí)候發(fā)生串?dāng)?shù)據(jù)，比如AB線程分別處理安琪拉和妲己的請求，A線程本來處理安琪拉的請求，結(jié)果訪問到妲己的數(shù)據(jù)上了，把妲己支付寶的錢轉(zhuǎn)走了。
所以就可以把安琪拉的數(shù)據(jù)跟A線程綁定，線程處理完之后解除綁定。
面試官：那把你剛才說的場景用偽代碼實(shí)現(xiàn)一下，來筆給你！
安琪拉：ok
//存放用戶信息的ThreadLocal
private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>();
public Response handleRequest(UserInfo userInfo) {
Response response = new Response();
try {
// 1.用戶信息set到線程局部變量中
userInfoThreadLocal.set(userInfo);
doHandle();
} finally {
// 3.使用完移除掉
userInfoThreadLocal.remove();
}
return response;
}
//業(yè)務(wù)邏輯處理
private void doHandle () {
// 2.實(shí)際用的時(shí)候取出來
UserInfo userInfo = userInfoThreadLocal.get();
//查詢用戶資產(chǎn)
queryUserAsset(userInfo);
}
1.2.3 步驟很清楚了。
面試官：那你跟我說說Threadlocal 怎么實(shí)現(xiàn)線程變量的隔離的？
安琪拉：Oh, 這么快進(jìn)入正題，我先給你畫個(gè)圖，如下
面試官：圖我看了，那你對著前面你寫的代碼講一下對應(yīng)圖中流程。
安琪拉：沒問題
首先我們通過
ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal()初始化了一個(gè)Threadlocal 對象，就是上圖中說的Threadlocal 引用，這個(gè)引用指向堆中的ThreadLocal 對象；然后我們調(diào)用
userInfoThreadLocal.set(userInfo);這里做了什么事呢？我們把源代碼拿出來，看一看就清晰了。
我們知道 Thread 類有個(gè) ThreadLocalMap 成員變量，這個(gè)Map key是Threadlocal 對象，value是你要存放的線程局部變量。
# Threadlocal類 Threadlocal.class
public void set(T value) {
//獲取當(dāng)前線程Thread，就是上圖畫的Thread 引用
Thread t = Thread.currentThread();
//Thread類有個(gè)成員變量ThreadlocalMap，拿到這個(gè)Map
ThreadLocalMap map = getMap(t);
if (map != null)
//this指的就是Threadlocal對象
map.set(this, value);
else
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
//獲取線程的ThreadLocalMap
return t.threadLocals;
}
void createMap(Thread t, T firstValue) {
//初始化
t.threadLocals = new ThreadLocalMap(this, firstValue);
}# Thread類 Thread.class
public class Thread implements Runnable {
//每個(gè)線程都有自己的ThreadLocalMap 成員變量
ThreadLocal.ThreadLocalMap threadLocals = null;
}這里是在當(dāng)前線程對象的ThreadlocalMap中put了一個(gè)元素(Entry)，key是Threadlocal對象，value是userInfo。
理解二件事就都清楚了：
ThreadLocalMap 類的定義在 Threadlocal中。
第一，Thread 對象是Java語言中線程運(yùn)行的載體，每個(gè)線程都有對應(yīng)的Thread 對象，存放線程相關(guān)的一些信息， 第二，Thread類中有個(gè)成員變量ThreadlocalMap，你就把他當(dāng)成普通的Map，key存放的是Threadlocal對象，value是你要跟線程綁定的值（線程隔離的變量），比如這里是用戶信息對象（UserInfo）。
面試官：你剛才說Thread 類有個(gè) ThreadlocalMap 屬性的成員變量，但是ThreadlocalMap 的定義卻在Threadlocal 中，為什么這么做？
安琪拉：我們看下ThreadlocalMap的說明
class ThreadLocalMap
* ThreadLocalMap is a customized hash map suitable only for
* maintaining thread local values. No operations are exported
* outside of the ThreadLocal class. The class is package private to
* allow declaration of fields in class Thread. To help deal with
* very large and long-lived usages, the hash table entries use
* WeakReferences for keys. However, since reference queues are not
* used, stale entries are guaranteed to be removed only when
* the table starts running out of space.
大概意思是ThreadLocalMap 就是為維護(hù)線程本地變量而設(shè)計(jì)的，只做這一件事情。
這個(gè)也是為什么 ThreadLocalMap 是Thread的成員變量，但是卻是Threadlocal 的內(nèi)部類（非public，只有包訪問權(quán)限，Thread和Threadlocal都在java.lang 包下），就是讓使用者知道ThreadLocalMap就只做保存線程局部變量這一件事的。
面試官：既然是線程局部變量，那為什么不用線程對象（Thread對象）作為key，這樣不是更清晰，直接用線程作為key獲取線程變量？
安琪拉：這樣設(shè)計(jì)會(huì)有個(gè)問題，比如: 我已經(jīng)把用戶信息存在線程變量里了，這個(gè)時(shí)候需要新增加一個(gè)線程變量，比方說新增用戶地理位置信息，我們ThreadlocalMap 的key用的是線程，再存一個(gè)地理位置信息，key都是同一個(gè)線程（key一樣），不就把原來的用戶信息覆蓋了嘛。Map.put(key,value) 操作熟悉吧，所以網(wǎng)上有些文章說ThreadlocalMap使用線程作為key是瞎扯的。
面試官：那新增地理位置信息應(yīng)該怎么做？
安琪拉：新創(chuàng)建一個(gè)Threadlocal對象就好了，因?yàn)門hreadLocalMap的key是Threadlocal 對象，比如新增地理位置，我就再 Threadlocal < Geo> geo = new Threadlocal
面試官：ThreadlocalMap 是什么數(shù)據(jù)結(jié)構(gòu)實(shí)現(xiàn)的？
安琪拉：跟HashMap 一樣，也是數(shù)組實(shí)現(xiàn)的。
代碼如下：
class ThreadLocalMap {
//初始容量
private static final int INITIAL_CAPACITY = 16;
//存放元素的數(shù)組
private Entry[] table;
//元素個(gè)數(shù)
private int size = 0;
}
table 就是存儲線程局部變量的數(shù)組，數(shù)組元素是Entry類，Entry由key和value組成，key是Threadlocal對象，value是存放的對應(yīng)線程變量
我們前面舉得例子，數(shù)組存儲結(jié)構(gòu)如下圖:
面試官：ThreadlocalMap 發(fā)生hash沖突怎么辦？跟HashMap 有什么區(qū)別？
安琪拉：【心想】第一次碰到有問ThreadlocalMap哈希沖突的，這個(gè)面試越來越有意思了。
說道：有區(qū)別的，對待哈希沖突，HashMap采用的鏈表 + 紅黑樹的形式，如下圖，鏈表長度過長(>8) 就會(huì)轉(zhuǎn)成紅黑樹:
HashMap詳解：
參考
安琪拉，公眾號：安琪拉的博客一個(gè)HashMap跟面試官扯了半個(gè)小時(shí)
ThreadlocalMap既沒有鏈表，也沒有紅黑樹，采用的是開放定址法 ，是這樣，是如果發(fā)生沖突，ThreadlocalMap直接往后找相鄰的下一個(gè)節(jié)點(diǎn)，如果相鄰節(jié)點(diǎn)為空，直接存進(jìn)去，如果不為空，繼續(xù)往后找，直到找到空的，把元素放進(jìn)去，或者元素個(gè)數(shù)超過數(shù)組長度閾值，進(jìn)行擴(kuò)容。
如下圖：還是以之前的例子講解，ThreadlocalMap 數(shù)組長度是4，現(xiàn)在存地理位置的時(shí)候發(fā)生hash沖突（位置1已經(jīng)有數(shù)據(jù)），那就把往后找，發(fā)現(xiàn)2 這個(gè)位置為空，就直接存放在2這個(gè)位置。
源代碼（如果閱讀起來困難，可以看完后文回過頭來閱讀）:
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// hashcode & 操作其實(shí)就是 %數(shù)組長度取余數(shù)，例如：數(shù)組長度是4，hashCode % (4-1) 就找到要存放元素的數(shù)組下標(biāo)
int i = key.threadLocalHashCode & (len-1);
//找到數(shù)組的空槽（=null），一般ThreadlocalMap存放元素不會(huì)很多
for (Entry e = tab[i];
e != null; //找到數(shù)組的空槽（=null）
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//如果key值一樣，算是更新操作，直接替換
if (k == key) {
e.value = value;
return;
}
//key為空，做替換清理動(dòng)作，這個(gè)后面聊WeakReference的時(shí)候講
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
//新new一個(gè)Entry
tab[i] = new Entry(key, value);
//數(shù)組元素個(gè)數(shù)+1
int sz = ++size;
//如果沒清理掉元素或者存放元素個(gè)數(shù)超過數(shù)組閾值，進(jìn)行擴(kuò)容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
//順序遍歷 +1 到了數(shù)組尾部，又回到數(shù)組頭部（0這個(gè)位置）
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
// get()方法，根據(jù)ThreadLocal key獲取線程變量
private Entry getEntry(ThreadLocal<?> key) {
//計(jì)算hash值 & 操作其實(shí)就是 %數(shù)組長度取余數(shù)，例如：數(shù)組長度是4，hashCode % (4-1) 就找到要查詢的數(shù)組地址
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//快速判斷 如果這個(gè)位置有值，key相等表示找到了，直接返回
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e); //miss之后順序往后找（鏈地址法，這個(gè)后面再介紹）
}
面試官：我看你最前面圖中畫的ThreadlocalMap 中key是 WeakReference類型，能講講Java中有幾種類似的引用，什么區(qū)別嗎？
安琪拉：可以
強(qiáng)引用是使用最普遍的引用。如果一個(gè)對象具有強(qiáng)引用，那垃圾回收器絕不會(huì)回收它，當(dāng)內(nèi)存空間不足時(shí)， Java虛擬機(jī)寧愿拋出OutOfMemoryError錯(cuò)誤，使程序異常終止，也不會(huì)靠隨意回收具有強(qiáng)引用的對象來解決內(nèi)存不足的問題。如果一個(gè)對象只具有軟引用，則內(nèi)存空間充足時(shí)，垃圾回收器就不會(huì)回收它；如果內(nèi)存空間不足了，就會(huì)回收這些對象的內(nèi)存。 弱引用與軟引用的區(qū)別在于：只具有弱引用的對象擁有更短暫的生命周期。在垃圾回收器線程掃描內(nèi)存區(qū)域時(shí)，一旦發(fā)現(xiàn)了只具有弱引用的對象，不管當(dāng)前內(nèi)存空間足夠與否，都會(huì)回收它的內(nèi)存。不過，由于垃圾回收器是一個(gè)優(yōu)先級很低的線程，因此不一定會(huì)很快發(fā)現(xiàn)那些只具有弱引用的對象。 虛引用顧名思義，就是形同虛設(shè)。與其他幾種引用都不同，虛引用并不會(huì)決定對象的生命周期。如果一個(gè)對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時(shí)候都可能被垃圾回收器回收。
妥妥的八股文啊！尷尬(─.─|||。
面試官：那你能講講為什么ThreadlocalMap 中key 設(shè)計(jì)成 WeakReference（弱引用）類型嗎？
安琪拉：可以的，為了盡最大努力避免內(nèi)存泄漏。
面試官：能詳細(xì)講講嗎？為什么是盡最大努力，你前面也講被WeakReference 引用的對象會(huì)直接被GC（內(nèi)存回收器） 回收，為什么不是直接避免了內(nèi)存泄漏呢？
安琪拉：我們還是看下下面這張圖
private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>();
userInfoThreadLocal.set(userInfo);
這里的引用關(guān)系是userInfoThreadLocal 引用了ThreadLocal對象，這是個(gè)強(qiáng)引用，ThreadLocal對象同時(shí)也被ThreadlocalMap的key引用，這是個(gè)WeakReference引用，我們前面說GC要回收ThreadLocal對象的前提是它只被WeakReference引用，沒有任何強(qiáng)引用。
為了方便大家理解弱引用，我寫了段Demo程序
public static void main(String[] args) {
Object angela = new Object();
//弱引用
WeakReference<Object> weakReference = new WeakReference<>(angela);
//angela和弱引用指向同一個(gè)對象
System.out.println(angela);//java.lang.Object@4550017c
System.out.println(weakReference.get());//java.lang.Object@4550017c
//將強(qiáng)引用angela置為null，這個(gè)對象就只剩下弱引用了,內(nèi)存夠用，弱引用也會(huì)被回收
angela = null;
System.gc();//內(nèi)存夠用不會(huì)自動(dòng)gc，手動(dòng)喚醒gc
System.out.println(angela);//null
System.out.println(weakReference.get());//null
}
可以看到一旦一個(gè)對象只被弱引用引用，GC的時(shí)候就會(huì)回收這個(gè)對象。
所以只要ThreadLocal對象如果還被 userInfoThreadLocal（強(qiáng)引用） 引用著，GC是不會(huì)回收被WeakReference引用的對象的。
面試官：那既然ThreadLocal對象有強(qiáng)引用，回收不掉，干嘛還要設(shè)計(jì)成WeakReference類型呢？
安琪拉：ThreadLocal的設(shè)計(jì)者考慮到線程往往生命周期很長，比如經(jīng)常會(huì)用到線程池，線程一直存活著，根據(jù)JVM 根搜索算法，一直存在 Thread -> ThreadLocalMap -> Entry（元素）這樣一條引用鏈路, 如下圖，如果key不設(shè)計(jì)成WeakReference類型，是強(qiáng)引用的話，就一直不會(huì)被GC回收，key就一直不會(huì)是null，不為null Entry元素就不會(huì)被清理（ThreadLocalMap是根據(jù)key是否為null來判斷是否清理Entry）
所以ThreadLocal的設(shè)計(jì)者認(rèn)為只要ThreadLocal 所在的作用域結(jié)束了工作被清理了，GC回收的時(shí)候就會(huì)把key引用對象回收，key置為null，ThreadLocal會(huì)盡力保證Entry清理掉來最大可能避免內(nèi)存泄漏。
來看下代碼
//元素類
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value; //key是從父類繼承的，所以這里只有value
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//WeakReference 繼承了Reference，key是繼承了范型的referent
public abstract class Reference<T> {
//這個(gè)就是被繼承的key
private T referent;
Reference(T referent) {
this(referent, null);
}
}
Entry 繼承了WeakReference類，Entry 中的 key 是WeakReference類型的，在Java 中當(dāng)對象只被 WeakReference 引用，沒有其他對象引用時(shí)，被WeakReference 引用的對象發(fā)生GC 時(shí)會(huì)直接被回收掉。
面試官：那如果Threadlocal 對象一直有強(qiáng)引用，那怎么辦？豈不是有內(nèi)存泄漏風(fēng)險(xiǎn)。
安琪拉：最佳實(shí)踐是用完手動(dòng)調(diào)用remove函數(shù)。
我們看下源碼：
class Threadlocal {
public void remove() {
//這個(gè)是拿到線程的ThreadLocalMap
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this); //this就是ThreadLocal對象，移除，方法在下面
}
}
class ThreadlocalMap {
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
//計(jì)算位置
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//清理
if (e.get() == key) {
e.clear();
expungeStaleEntry(i); //清理空槽
return;
}
}
}
}
//這個(gè)方法就是做元素清理
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
//把staleSlot的value置為空，然后數(shù)組元素置為空
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--; //元素個(gè)數(shù)-1
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//k 為null代表引用對象被GC回收掉了
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
//因?yàn)樵貍€(gè)數(shù)減少了，就把后面的元素重新hash
int h = k.threadLocalHashCode & (len - 1);
//hash地址不相等，就代表這個(gè)元素之前發(fā)生過hash沖突(本來應(yīng)該放在這沒放在這)，
//現(xiàn)在因?yàn)橛性乇灰瞥耍苡锌赡茉瓉頉_突的位置空出來了，重試一次
if (h != i) {
tab[i] = null;
//繼續(xù)采用鏈地址法存放元素
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
面試官：你有沒有用Threadlocal的工程實(shí)際經(jīng)歷，給我講講。
安琪拉：有啊！
之前我跟你們一面面試官聊過，我是怎么把支付寶后臺負(fù)責(zé)的系統(tǒng)四十幾個(gè)核心rpc接口性能大幅度提升的，下面這個(gè)就是其中一個(gè)接口切流之后的效果，其中就用到了Threadlocal。
面試官：嗯，說說。
安琪拉：我剛才說有四十多個(gè)接口要做技改優(yōu)化，那風(fēng)險(xiǎn)是很高的，我需要保證接口切換后業(yè)務(wù)不受影響，也叫等效切換。
流程是這樣的：
把這四十多個(gè)接口按照業(yè)務(wù)含義定義了接口常量名稱，比如接口名 alipay.quickquick.follow.angela；按照接口的流量從低到高開始切流，提前配置中心配置好每個(gè)接口的切流比例和用戶白名單； 切流也有講究，先按照userId白名單切，再按照userId尾號切百分比，完全沒問題再完整切； 在頂層抽象模版方法的入口通過ThreadLocal Set 接口名，把接口名塞進(jìn)去； 然后我在切流的地方通過ThreadLocal 獲取接口名，用于接口切流判斷切流；
面試官：最后一個(gè)問題，如果我有很多變量都要塞到ThreadlocalMap中，那豈不是要申明很多個(gè)Threadlocal 對象？有沒有好的解決辦法。
安琪拉：我們的最佳實(shí)踐是搞個(gè)再封裝一下，把ThreadLocalMap 的value 弄成Map就好了，這樣只要一個(gè)Threadlocal 對象就好了。
面試官：能詳細(xì)講講嗎？
安琪拉：講不動(dòng)了，太累了。
面試官：講講。
安琪拉：真不想講了。
面試官：那今天先到這，您出了這個(gè)門右拐，回去等通知吧！