概述
本文首發(fā)于個人技術(shù)博客[Java并發(fā)包學習七]解密ThreadLocal
相信讀者在網(wǎng)上也看了很多關(guān)于ThreadLocal的資料被去，很多博客都這樣說：ThreadLocal為解決多線程程序的并發(fā)問題提供了一種新的思路昨登；ThreadLocal的目的是為了解決多線程訪問資源時的共享問題恭应。如果你也這樣認為的绘搞，那現(xiàn)在給你10秒鐘够委，清空之前對ThreadLocal的錯誤的認知鄙币！
看看JDK中的源碼是怎么寫的：
This class provides thread-local variables. These variables differ from
their normal counterparts in that each thread that accesses one (via its
{@code get} or {@code set} method) has its own, independently initialized
copy of the variable. {@code ThreadLocal} 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方法訪問)時能保證各個線程里的變量相對獨立于其他線程內(nèi)的變量因惭。ThreadLocal實例通常來說都是
private static類型的，用于關(guān)聯(lián)線程和線程的上下文绩衷。
可以總結(jié)為一句話：ThreadLocal的作用是提供線程內(nèi)的局部變量蹦魔，這種變量在線程的生命周期內(nèi)起作用激率，減少同一個線程內(nèi)多個函數(shù)或者組件之間一些公共變量的傳遞的復雜度。
舉個例子勿决，我出門需要先坐公交再做地鐵乒躺，這里的坐公交和坐地鐵就好比是同一個線程內(nèi)的兩個函數(shù)，我就是一個線程低缩，我要完成這兩個函數(shù)都需要同一個東西：公交卡（北京公交和地鐵都使用公交卡）嘉冒，那么我為了不向這兩個函數(shù)都傳遞公交卡這個變量（相當于不是一直帶著公交卡上路），我可以這么做：將公交卡事先交給一個機構(gòu)咆繁，當我需要刷卡的時候再向這個機構(gòu)要公交卡（當然每次拿的都是同一張公交卡）讳推。這樣就能達到只要是我(同一個線程)需要公交卡，何時何地都能向這個機構(gòu)要的目的玩般。
有人要說了：你可以將公交卡設(shè)置為全局變量啊银觅，這樣不是也能何時何地都能取公交卡嗎？但是如果有很多個人（很多個線程）呢壤短？大家可不能都使用同一張公交卡吧(我們假設(shè)公交卡是實名認證的)设拟，這樣不就亂套了嘛。現(xiàn)在明白了吧久脯？這就是ThreadLocal設(shè)計的初衷：提供線程內(nèi)部的局部變量纳胧，在本線程內(nèi)隨時隨地可取，隔離其他線程帘撰。
ThreadLocal基本操作
構(gòu)造函數(shù)
ThreadLocal的構(gòu)造函數(shù)簽名是這樣的：
/**
* Creates a thread local variable.
* @see #withInitial(java.util.function.Supplier)
*/
public ThreadLocal() {
}
內(nèi)部啥也沒做跑慕。
initialValue函數(shù)
initialValue函數(shù)用來設(shè)置ThreadLocal的初始值，函數(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)部類的形式被重載如筛，以指定初始值堡牡，比如：
package com.winwill.test;
/**
* @author qifuguang
* @date 15/9/2 00:05
*/
public class TestThreadLocal {
private static final ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return Integer.valueOf(1);
}
};
}
get函數(shù)
該函數(shù)用來獲取與當前線程關(guān)聯(lián)的ThreadLocal的值，函數(shù)簽名如下：
public T get()
如果當前線程沒有該ThreadLocal的值杨刨，則調(diào)用initialValue函數(shù)獲取初始值返回晤柄。
set函數(shù)
set函數(shù)用來設(shè)置當前線程的該ThreadLocal的值，函數(shù)簽名如下：
public void set(T value)
設(shè)置當前線程的ThreadLocal的值為value妖胀。
remove函數(shù)
remove函數(shù)用來將當前線程的ThreadLocal綁定的值刪除芥颈，函數(shù)簽名如下：
public void remove()
在某些情況下需要手動調(diào)用該函數(shù)惠勒，防止內(nèi)存泄露。
代碼演示
學習了最基本的操作之后浇借，我們用一段代碼來演示ThreadLocal的用法捉撮，該例子實現(xiàn)下面這個場景：
有5個線程，這5個線程都有一個值value妇垢，初始值為0巾遭，線程運行時用一個循環(huán)往value值相加數(shù)字。
代碼實現(xiàn)：
package com.winwill.test;
/**
* @author qifuguang
* @date 15/9/2 00:05
*/
public class TestThreadLocal {
private static final ThreadLocal<Integer> value = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
new Thread(new MyThread(i)).start();
}
}
static class MyThread implements Runnable {
private int index;
public MyThread(int index) {
this.index = index;
}
public void run() {
System.out.println("線程" + index + "的初始value:" + value.get());
for (int i = 0; i < 10; i++) {
value.set(value.get() + i);
}
System.out.println("線程" + index + "的累加value:" + value.get());
}
}
}
執(zhí)行結(jié)果為：
線程0的初始value:0
線程3的初始value:0
線程2的初始value:0
線程2的累加value:45
線程1的初始value:0
線程3的累加value:45
線程0的累加value:45
線程1的累加value:45
線程4的初始value:0
線程4的累加value:45
可以看到闯估，各個線程的value值是相互獨立的灼舍，本線程的累加操作不會影響到其他線程的值，真正達到了線程內(nèi)部隔離的效果涨薪。
如何實現(xiàn)的
看了基本介紹骑素，也看了最簡單的效果演示之后，我們更應(yīng)該好好研究下ThreadLocal內(nèi)部的實現(xiàn)原理刚夺。如果給你設(shè)計献丑，你會怎么設(shè)計？相信大部分人會有這樣的想法：
每個ThreadLocal類創(chuàng)建一個Map侠姑，然后用線程的ID作為Map的key创橄，實例對象作為Map的value，這樣就能達到各個線程的值隔離的效果莽红。
沒錯妥畏，這是最簡單的設(shè)計方案，JDK最早期的ThreadLocal就是這樣設(shè)計的安吁。JDK1.3（不確定是否是1.3）之后ThreadLocal的設(shè)計換了一種方式醉蚁。
我們先看看JDK8的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) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
其中g(shù)etMap的源碼：
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
setInitialValue函數(shù)的源碼：
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;
}
createMap函數(shù)的源碼：
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
簡單解析一下，get方法的流程是這樣的：
- 首先獲取當前線程
- 根據(jù)當前線程獲取一個Map
- 如果獲取的Map不為空鬼店，則在Map中以ThreadLocal的引用作為key來在Map中獲取對應(yīng)的value e网棍，否則轉(zhuǎn)到5
- 如果e不為null，則返回e.value妇智，否則轉(zhuǎn)到5
- Map為空或者e為空确沸，則通過
initialValue函數(shù)獲取初始值value，然后用ThreadLocal的引用和value作為firstKey和firstValue創(chuàng)建一個新的Map
然后需要注意的是Thread類中包含一個成員變量：
ThreadLocal.ThreadLocalMap threadLocals = null;
所以俘陷，可以總結(jié)一下ThreadLocal的設(shè)計思路：
每個Thread維護一個ThreadLocalMap映射表，這個映射表的key是ThreadLocal實例本身观谦，value是真正需要存儲的Object拉盾。
這個方案剛好與我們開始說的簡單的設(shè)計方案相反。查閱了一下資料豁状，這樣設(shè)計的主要有以下幾點優(yōu)勢：
- 這樣設(shè)計之后每個Map的Entry數(shù)量變小了：之前是Thread的數(shù)量捉偏，現(xiàn)在是ThreadLocal的數(shù)量倒得，能提高性能，據(jù)說性能的提升不是一點兩點(沒有親測)
- 當Thread銷毀之后對應(yīng)的ThreadLocalMap也就隨之銷毀了夭禽，能減少內(nèi)存使用量霞掺。
再深入一點
先交代一個事實：ThreadLocalMap是使用ThreadLocal的弱引用作為Key的：
static class ThreadLocalMap {
/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object). Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table. Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
...
...
}
下圖是本文介紹到的一些對象之間的引用關(guān)系圖，實線表示強引用讹躯，虛線表示弱引用：
然后網(wǎng)上就傳言菩彬，ThreadLocal會引發(fā)內(nèi)存泄露，他們的理由是這樣的：
如上圖潮梯，ThreadLocalMap使用ThreadLocal的弱引用作為key骗灶，如果一個ThreadLocal沒有外部強引用引用他，那么系統(tǒng)gc的時候秉馏，這個ThreadLocal勢必會被回收耙旦，這樣一來，ThreadLocalMap中就會出現(xiàn)key為null的Entry萝究，就沒有辦法訪問這些key為null的Entry的value免都，如果當前線程再遲遲不結(jié)束的話，這些key為null的Entry的value就會一直存在一條強引用鏈：
ThreadLocal Ref -> Thread -> ThreaLocalMap -> Entry -> value
永遠無法回收帆竹，造成內(nèi)存泄露绕娘。
我們來看看到底會不會出現(xiàn)這種情況。
其實馆揉，在JDK的ThreadLocalMap的設(shè)計中已經(jīng)考慮到這種情況业舍，也加上了一些防護措施，下面是ThreadLocalMap的getEntry方法的源碼：
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ù)的源碼：
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)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
expungeStaleEntry函數(shù)的源碼：
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// 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();
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
整理一下ThreadLocalMap的getEntry函數(shù)的流程：
- 首先從ThreadLocal的直接索引位置(通過ThreadLocal.threadLocalHashCode & (len-1)運算得到)獲取Entry e升酣，如果e不為null并且key相同則返回e舷暮；
- 如果e為null或者key不一致則向下一個位置查詢，如果下一個位置的key和當前需要查詢的key相等噩茄，則返回對應(yīng)的Entry下面，否則，如果key值為null绩聘，則擦除該位置的Entry沥割，否則繼續(xù)向下一個位置查詢
在這個過程中遇到的key為null的Entry都會被擦除，那么Entry內(nèi)的value也就沒有強引用鏈凿菩，自然會被回收机杜。仔細研究代碼可以發(fā)現(xiàn)，set操作也有類似的思想衅谷，將key為null的這些Entry都刪除椒拗，防止內(nèi)存泄露。
但是光這樣還是不夠的，上面的設(shè)計思路依賴一個前提條件：要調(diào)用ThreadLocalMap的genEntry函數(shù)或者set函數(shù)蚀苛。這當然是不可能任何情況都成立的在验，所以很多情況下需要使用者手動調(diào)用ThreadLocal的remove函數(shù)，手動刪除不再需要的ThreadLocal堵未，防止內(nèi)存泄露腋舌。所以JDK建議將ThreadLocal變量定義成private static的，這樣的話ThreadLocal的生命周期就更長渗蟹，由于一直存在ThreadLocal的強引用块饺，所以ThreadLocal也就不會被回收，也就能保證任何時候都能根據(jù)ThreadLocal的弱引用訪問到Entry的value值拙徽，然后remove它刨沦，防止內(nèi)存泄露。
