作業面試中經常遇到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 = https://www.cnblogs.com/yidengjiagou/p/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 = https://www.cnblogs.com/yidengjiagou/p/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();
}
}
我是「一燈架構」，如果本文對你有幫助，歡迎各位小伙伴點贊、評論和關注，感謝各位老鐵，我們下期見
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/519229.html
標籤：Java