工作面試中經常遇到ThreadLocal，但是很多同學并不了解ThreadLocal實現原理，到底為什么會發生內存泄漏也是一知半解？今天一燈帶你深入剖析ThreadLocal源碼，總結ThreadLocal使用規范，解析ThreadLocal高頻面試題。
1. ThreadLocal是什么
ThreadLocal是線程本地變量，就是線程的私有變量，不同線程之間相互隔離，無法共享，相當于每個線程拷貝了一份變量的副本。
目的就是在多線程環境中，無需加鎖，也能保證數據的安全性。
2. ThreadLocal的使用
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建ThreadLocal
static ThreadLocal<String> threadLocal = new ThreadLocal<>();
public static void main(String[] args){
// 2. 給ThreadLocal賦值
threadLocal.set("關注公眾號:一燈架構");
// 3. 從ThreadLocal中取值
String result = threadLocal.get();
System.out.println(result); // 輸出 關注公眾號:一燈架構
// 4. 刪除ThreadLocal中的數據
threadLocal.remove();
System.out.println(threadLocal.get()); // 輸出null
}
}
ThreadLocal的用法非常簡單，創建ThreadLocal的時候指定泛型類型，然后就是賦值、取值、刪除值的操作。
不同線程之間，ThreadLocal數據是隔離的，測試一下：
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建ThreadLocal
static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
public static void main(String[] args){
IntStream.range(0, 5).forEach(i -> {
// 創建5個線程，分別給threadLocal賦值、取值
new Thread(() -> {
// 2. 給ThreadLocal賦值
threadLocal.set(i);
// 3. 從ThreadLocal中取值
System.out.println(Thread.currentThread().getName()
+ "," + threadLocal.get());
}).start();
});
}
}
輸出結果：
Thread-2,2
Thread-4,4
Thread-1,1
Thread-0,0
Thread-3,3
可以看出不同線程之間的ThreadLocal數據相互隔離，互不影響，這樣的實現效果有哪些應用場景呢？
3. ThreadLocal應用場景
ThreadLocal的應用場景主要分為兩類：
避免對象在方法之間層層傳遞，打破層次間約束。比如用戶信息，在很多地方都需要用到，層層往下傳遞，比較麻煩。這時候就可以把用戶信息放到ThreadLocal中，需要的地方可以直接使用。
拷貝對象副本，減少初始化操作，并保證數據安全。比如數據庫連接、Spring事務管理、SimpleDataFormat格式化日期，都是使用的ThreadLocal，即避免每個線程都初始化一個對象，又保證了多線程下的數據安全。
使用ThreadLocal保證SimpleDataFormat格式化日期的線程安全，代碼類似下面這樣：
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建ThreadLocal
static ThreadLocal<SimpleDateFormat> threadLocal =
ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
public static void main(String[] args){
IntStream.range(0, 5).forEach(i -> {
// 創建5個線程，分別從threadLocal取出SimpleDateFormat，然后格式化日期
new Thread(() -> {
try {
System.out.println(threadLocal.get().parse("2022-11-11 00:00:00"));
} catch (ParseException e) {
throw new RuntimeException(e);
}
}).start();
});
}
}
4. ThreadLocal實現原理
ThreadLocal底層使用ThreadLocalMap存儲數據，而ThreadLocalMap內部是一個數組，數組里面存儲的是Entry對象，Entry對象里面使用key-value存儲數據，key是ThreadLocal實例對象本身，value是ThreadLocal的泛型對象值。
4.1 ThreadLocalMap源碼
static class ThreadLocalMap {
// Entry對象，WeakReference是弱引用，當沒有引用指向時，會被GC回收
static class Entry extends WeakReference<ThreadLocal<?>> {
// ThreadLocal泛型對象值
Object value;
// 構造方法，傳參是key-value
// key是ThreadLocal對象實例，value是ThreadLocal泛型對象值
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// Entry數組，用來存儲ThreadLocal數據
private Entry[] table;
// 數組的默認容量大小
private static final int INITIAL_CAPACITY = 16;
// 擴容的閾值，默認是數組大小的三分之二
private int threshold;
private void setThreshold(int len){
threshold = len * 2 / 3;
}
}4.2 set方法源碼
// 給ThreadLocal設值
public void set(T value){
// 獲取當前線程對象
Thread t = Thread.currentThread();
// 獲取此線程對象中的ThreadLocalMap對象
ThreadLocalMap map = getMap(t);
// 如果ThreadLocal已經設過值，直接設值，否則初始化
if (map != null)
// 設值的key就是當前ThreadLocal對象實例，value是ThreadLocal泛型對象值
map.set(this, value);
else
// 初始化ThreadLocalMap
createMap(t, value);
}
再看一下實際的set方法源碼：
// key就是當前ThreadLocal對象實例，value是ThreadLocal泛型對象值
private void set(ThreadLocal<?> key, Object value){
// 獲取ThreadLocalMap中的Entry數組
Entry[] tab = table;
int len = tab.length;
// 計算key在數組中的下標，也就是ThreadLocal的hashCode和數組大小-1取余
int i = key.threadLocalHashCode & (len - 1);
// 查找流程：從下標i開始，判斷下標位置是否有值，
// 如果有值判斷是否等于當前ThreadLocal對象實例，等于就覆蓋，否則繼續向后遍歷數組，直到找到空位置
for (Entry e = tab[i];
e != null;
// nextIndex 就是讓在不超過數組長度的基礎上，把數組的索引位置 + 1
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
// 如果等于當前ThreadLocal對象實例，直接覆蓋
if (k == key) {
e.value = value;
return;
}
// 當前key是null，說明ThreadLocal對象實例已經被GC回收了，直接覆蓋
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 找到空位置，創建Entry對象
tab[i] = new Entry(key, value);
int sz = ++size;
// 當數組大小大于等于擴容閾值(數組大小的三分之二)時，進行擴容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
set方法具體流程如下：
從源碼和流程圖中得知，ThreadLocal是通過線性探測法解決哈希沖突的，線性探測法具體賦值流程如下：
通過key的hashcode找到數組下標
如果數組下標位置是空或者等于當前ThreadLocal對象，直接覆蓋值結束
如果不是空，就繼續向下遍歷，遍歷到數組結尾后，再從頭開始遍歷，直到找到數組為空的位置，在此位置賦值結束
線性探測法這種特殊的賦值流程，導致取值的時候，也要走一遍類似的流程。
4.3 get方法源碼
// 從ThreadLocal從取值
public T get(){
// 獲取當前線程對象
Thread t = Thread.currentThread();
// 獲取此線程對象中的ThreadLocalMap對象
ThreadLocalMap map = getMap(t);
if (map != null) {
// 通過ThreadLocal實例對象作為key，在Entry數組中查找數據
ThreadLocalMap.Entry e = map.getEntry(this);
// 如果不為空，表示找到了，直接返回
if (e != null) {
T result = (T)e.value;
return result;
}
}
// 如果ThreadLocalMap是null，就執行初始化ThreadLocalMap操作
return setInitialValue();
}
再看一下具體的遍歷Entry數組的邏輯：
// 具體的遍歷Entry數組的方法
private Entry getEntry(ThreadLocal<?> key){
// 通過hashcode計算數組下標位置
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 如果下標位置對象不為空，并且等于當前ThreadLocal實例對象，直接返回
if (e != null && e.get() == key)
return e;
else
// 如果不是，需要繼續向下遍歷Entry數組
return getEntryAfterMiss(key, i, e);
}
再看一下線性探測法特殊的取值方法：
// 如果不是，需要繼續向下遍歷Entry數組
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e){
Entry[] tab = table;
int len = tab.length;
// 循環遍歷數組，直到找到ThreadLocal對象，或者遍歷到數組為空的位置
while (e != null) {
ThreadLocal<?> k = e.get();
// 如果等于當前ThreadLocal實例對象，表示找到了，直接返回
if (k == key)
return e;
// key是null，表示ThreadLocal實例對象已經被GC回收，就幫忙清除value
if (k == null)
expungeStaleEntry(i);
else
// 索引位置+1，表示繼續向下遍歷
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
// 索引位置+1，表示繼續向下遍歷，遍歷到數組結尾，再從頭開始遍歷
private static int nextIndex(int i, int len){
return ((i + 1 < len) ? i + 1 : 0);
}
ThreadLocal的get方法流程如下：
4.4 remove方法源碼
remove方法流程跟set、get方法類似，都是遍歷數組，找到ThreadLocal實例對象后，刪除key、value，再刪除Entry對象結束。
public void remove(){
// 獲取當前線程的ThreadLocalMap對象
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
// 具體的刪除方法
private void remove(ThreadLocal<?> key){
ThreadLocal.ThreadLocalMap.Entry[] tab = table;
int len = tab.length;
// 計算數組下標
int i = key.threadLocalHashCode & (len - 1);
// 遍歷數組，直到找到空位置，
// 或者值等于當前ThreadLocal對象，才結束
for (ThreadLocal.ThreadLocalMap.Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
// 找到后，刪除key、value，再刪除Entry對象
if (e.get() == key) {
e.clear();
expungeStaleEntry(i);
return;
}
}
}5. ThreadLocal使用注意事項
使用ThreadLocal結束，一定要調用remove方法，清理掉threadLocal數據。具體流程類似下面這樣：
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建ThreadLocal
static ThreadLocal<User> threadLocal = new ThreadLocal<>();
public void method(){
try {
User user = getUser();
// 2. 給threadLocal賦值
threadLocal.set(user);
// 3. 執行其他業務邏輯
doSomething();
} finally {
// 4. 清理threadLocal數據
threadLocal.remove();
}
}
}
如果忘了調用remove方法，可能會導致兩個嚴重的問題：
導致內存溢出如果線程的生命周期很長，一直往ThreadLocal中放數據，卻沒有刪除，最終產生OOM
導致數據錯亂如果使用了線程池，一個線程執行完任務后并不會被銷毀，會繼續執行下一個任務，導致下個任務訪問到了上個任務的數據。
6. 常見面試題剖析
看完了ThreadLocal源碼，再回答幾道面試題，檢驗一下學習成果怎么樣。
6.1 ThreadLocal是怎么保證數據安全性的？
ThreadLocal底層使用的ThreadLocalMap存儲數據，而ThreadLocalMap是線程Thread的私有變量，不同線程之間數據隔離，所以即使ThreadLocal的set、get、remove方法沒有加鎖，也能保證線程安全。
6.2 ThreadLocal底層為什么使用數組？而不是一個對象？
因為在一個線程中可以創建多個ThreadLocal實例對象，所以要用數組存儲，而不是用一個對象。
6.3 ThreadLocal是怎么解決哈希沖突的？
ThreadLocal使用的線性探測法法解決哈希沖突，線性探測法法具體賦值流程如下：
通過key的hashcode找到數組下標
如果數組下標位置是空或者等于當前ThreadLocal對象，直接覆蓋值結束
如果不是空，就繼續向下遍歷，遍歷到數組結尾后，再從頭開始遍歷，直到找到數組為空的位置，在此位置賦值結束
6.4 ThreadLocal為什么要用線性探測法解決哈希沖突？
我們都知道HashMap采用的是鏈地址法（也叫拉鏈法）解決哈希沖突，為什么ThreadLocal要用線性探測法解決哈希沖突？而不用鏈地址法呢？
我的猜想是可能是創作者偷懶、嫌麻煩，或者是ThreadLocal使用量較少，出現哈希沖突概率較低，不想那么麻煩。
使用鏈地址法需要引入鏈表和紅黑樹兩種數據結構，實現更復雜。而線性探測法沒有引入任何額外的數據結構，直接不斷遍歷數組。
結果就是，如果一個線程中使用很多個ThreadLocal，發生哈希沖突后，ThreadLocal的get、set性能急劇下降。
線性探測法相比鏈地址法優缺點都很明顯：
優點： 實現簡單，無需引入額外的數據結構。
缺點： 發生哈希沖突后，ThreadLocal的get、set性能急劇下降。
6.5 ThreadLocalMap的key為什么要設計成弱引用？
先說一下弱引用的特點：
弱引用的對象擁有更短暫的生命周期，在垃圾回收器線程掃描它所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。 不過，由于垃圾回收器是一個優先級很低的線程，因此不一定會很快發現那些只具有弱引用的對象。
ThreadLocalMap的key設計成弱引用后，會不會我們正在使用，就被GC回收了？
這個是不會的，因為我們一直在強引用著ThreadLocal實例對象。
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建ThreadLocal
static ThreadLocal<String> threadLocal = new ThreadLocal<>();
public static void main(String[] args){
// 2. 給ThreadLocal賦值
threadLocal.set("關注公眾號:一燈架構");
// 3. 從ThreadLocal中取值
String result = threadLocal.get();
// 手動觸發GC
System.gc();
System.out.println(result); // 輸出 關注公眾號:一燈架構
}
}
由上面代碼中得知，如果我們一直在使用threadLocal，觸發GC后，并不會threadLocal實例對象。
ThreadLocalMap的key設計成弱引用的目的就是：
防止我們在使用完ThreadLocal后，忘了調用remove方法刪除數據，導致數組中ThreadLocal數據一直不被回收。
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建ThreadLocal
static ThreadLocal<String> threadLocal = new ThreadLocal<>();
public static void main(String[] args){
// 2. 給ThreadLocal賦值
threadLocal.set("關注公眾號:一燈架構");
// 3. 使用完threadLocal，設置成null，模仿生命周期結束
threadLocal = null;
// 觸發GC，這時候ThreadLocalMap的key就會被回收，但是value還沒有被回收。
// 只有等到下次執行get、set方法遍歷數組，遍歷到這個位置，才會刪除這個無效的value
System.gc();
}
}
6.6 ThreadLocal為什么會出現內存泄漏？
ThreadLocal出現內存泄漏的原因，就是我們使用完ThreadLocal沒有執行remove方法刪除數據。
具體是哪些數據過多導致的內存泄漏呢？
一個是數組的Entry對象，Entry對象中key、value分別是ThreadLocal實例對象和泛型對象值。
因為我們在使用ThreadLocal的時候，總愛把ThreadLocal設置成類的靜態變量，直到線程生命周期結束，ThreadLocal對象數據才會被回收。
另一個是數組中Entry對象的value值，也就是泛型對象值。雖然ThreadLocalMap的key被設置成弱引用，會被GC回收，但是value并沒有被回收。需要等到下次執行get、set方法遍歷數組，遍歷到這個位置，才會刪除這個無效的value。這也是造成內存泄漏的原因之一。
6.7 怎么實現父子線程共享ThreadLocal數據？
只需要InheritableThreadLocal即可，當初始化子線程的時候，會從父線程拷貝ThreadLocal數據。
/**
* @author 一燈架構
* @apiNote ThreadLocal示例
**/
public class ThreadLocalDemo {
// 1. 創建可被子線程繼承數據的ThreadLocal
static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();
public static void main(String[] args){
// 2. 給ThreadLocal賦值
threadLocal.set("關注公眾號:一燈架構");
// 3. 啟動一個子線程，看是否能獲取到主線程數據
new Thread(() -> {
System.out.println(threadLocal.get()); // 輸出 關注公眾號:一燈架構
}).start();
}
}
