概述
1、在并發編程中，為了控制資料的正確性，我們往往需要使用鎖來來保證代碼塊的執行隔離性，但是在很多時候鎖的開銷太大了，而在某些情況下，我們的區域變數是執行緒私有的，每個執行緒都會有自己的獨自的變/量，這個時候我們可以不對這部分資料進行加鎖操作，于是ThredLocal應運而生，
2、ThredLocal顧名思義，是執行緒持有的本地變數，存放在ThredLocal中的變數不會同步到其他執行緒以及主執行緒，所有執行緒對于其他的執行緒變數都是不可見的，那么我們來看下它是如何實作的吧，
3、注意：光理論是不夠的，在此免費贈送5大JAVA架構專案實戰教程及大廠面試題庫，有興趣的可以進裙 783802103獲取，沒基礎勿進哦！
實作原理
ThredLocal在內部實作了一個靜態類ThreadLocalMap來對于變數進行存盤，并且在Thread類的內部使用到了這兩個成員變數
ThreadLocal.ThreadLocalMap threadLocals = null;
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
來呼叫ThreadLocalMap存盤當前執行緒的內部變數，
ThreadLocalMap的實作
ThreadLocalMap是鍵值對結構的map，但是他沒有直接使用HashMap，而是自己實作了一個，
Entry
Entry是ThreadLocalMap中定義的map節點，他以ThreadLocal弱參考為key，以Object為value的K-V形式的節點，使用弱參考是為了可以及時釋放記憶體避免記憶體泄漏，
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = https://www.cnblogs.com/chengxuyuanaa/p/v;
}
}
這里和HashMap不一樣的地方在于兩者解決hash沖突的方式的不同，HashMap采用的是鏈地址法，遇到沖突的時候將沖突的資料放入同一鏈表之中，等到鏈表到了一定程度再將鏈表轉化為紅黑樹，而ThreadLocalMap實作采用的是開放尋址法，它內部沒有使用鏈表結構，因此Entry內部沒有next或者是prev指標，ThreadLocalMap的開放尋址法是怎么實作的，請看接下來的原始碼，
成員變數
// map默認的初始化大小
private static final int INITIAL_CAPACITY = 16;
// 存盤map節點資料的陣列
private Entry[] table;
// map大小
private int size = 0;
// 臨界值，達到這個值的時候需要擴容
private int threshold;
// 當臨界值達到2/3的時候擴容
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
這里的陣列大小始終是2的冪次，原因和HashMap一樣，是為了在計算hash偏移的時候減少碰撞，
建構式
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化table
table = new Entry[INITIAL_CAPACITY];
// 計算第一個值的hash值
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 創建新的節點
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
set方法
private void set(ThreadLocal<?> key, Object value) {
// 獲取ThreadLocal的hash值偏移量
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();
// 如果節點key相等，即找到了我們想要的節點，
// 將值賦予節點
if (k == key) {
e.value = https://www.cnblogs.com/chengxuyuanaa/p/value;
return;
}
// 如果節點的key為空，說明弱參考已經把key回收了，那么需要做一波清理
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 如果沒有找到對應的節點說明該key不存在，創建新節點
tab[i] = new Entry(key, value);
int sz = ++size;
// 進行清理，如果清理結果沒能清理掉任何的舊節點，
// 并且陣列大小超出了臨界值，就進行rehash操作擴容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
看到這段代碼，開放尋址法的實作原理可以說是非常清楚了，首先計算節點的hash值，找到對應的位置，查看該位置是否為空，如果是空則插入，如果不為空，則順延至下個節點，直到找到空的位置插入，那么我們的查詢邏輯也呼之欲出：計算節點的hash值，找到對應的位置，查看該節點是否是我們想要找的節點，如果不是，則繼續往下順序尋找，
get方法
private Entry getEntry(ThreadLocal<?> key) {
// 計算hash值
int i = key.threadLocalHashCode & (table.length - 1);
// 獲取該hash值對應的陣列節點
Entry e = table[i];
if (e != null && e.get() == key)
// 如果節點不為空并且key一致，說明是我們找的節點，直接回傳
return e;
else
// 否則繼續往后尋找
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 如果節點不為空就一直找下去
while (e != null) {
ThreadLocal<?> k = e.get();
// key相同則說明找到，回傳該節點
if (k == key)
return e;
// key為空進行一次清理
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
replaceStaleEntry
// 這個方法的作用是在set操作的時候進行清理
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// slotToExpunge是之后開始清理的節點位置
int slotToExpunge = staleSlot;
// 往前尋找找到第一個為空的節點記錄下位置
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// 從staleSlot開始向后遍歷直到節點為空
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == key) {
// 如果節點的key一致，替換value的值
e.value = https://www.cnblogs.com/chengxuyuanaa/p/value;
// 將當前節點和staleSlot上的節點互換位置（將后方的值放到前方來，之前的值等待回收）
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 如果slotToExpunge和staleSlot相等，說明前面沒有需要清理的節點
// 則從當前節點開始進行清理
if (slotToExpunge == staleSlot)
slotToExpunge = i;
// 進行節點清理
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// 如果key為空并且slotToExpunge和staleSlot相等
// 把slotToExpunge賦值為當前節點
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 如果沒法找到key相等的節點，
// 則清空當前節點的value并生成新的節點
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 如果slotToExpunge和staleSlot不相等則需要進行清理（因為前方發現空的節點）
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
expungeStaleEntry
// 對節點進行清理
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 釋放當節點
tab[staleSlot].value = https://www.cnblogs.com/chengxuyuanaa/p/null;
tab[staleSlot] = null;
size--;
Entry e;
int i;
// 回圈尋找到第一個空節點
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// key為空進行節點釋放
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
// 如果key不為空，找到對應的節點應該在的位置
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
// 如果和當前節點位置不同，
// 則清理節點并且回圈找到后面的非空節點移到前面來
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
cleanSomeSlots
// 該方法用于清理空節點
private boolean cleanSomeSlots(int i, int n) {
// 標記是否有節點被清除
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
do {
i = nextIndex(i, len);
Entry e = tab[i];
// 如果有節點為空并且key為空
// 該節點需要被清除
if (e != null && e.get() == null) {
// 重置n的值并且標記removed為true
n = len;
removed = true;
// 清理該節點
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
rehash
// 當陣列的元素到達臨界值，進行擴容
private void rehash() {
// 先對所有的節點進行清理
expungeStaleEntries();
// 然后判斷臨界值是否進行擴容
// 此處由于先做過一次清理，這里的數字可能會和之前的臨界值判斷有縮小
// 所以此處臨界值判斷為threshold - threshold / 4
// 即1/2的size時進行擴容
if (size >= threshold - threshold / 4)
resize();
}
private void resize() {
// 獲取舊陣列，開辟新陣列
// 新陣列大小為舊陣列的2倍
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
int count = 0;
// 遍歷舊陣列
for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
// 如果節點不為空，判斷key是否為空
// 如果key為空，將節點置空幫助gc
// 如果key不為空將舊陣列的節點放入新陣列
// 放入方式和set實作一致，只是由于是剛創建的新陣列
// 不會有需要清理的資料，所以不需要額外清理
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = https://www.cnblogs.com/chengxuyuanaa/p/null;
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}
expungeStaleEntries
// 清理所有節點
private void expungeStaleEntries() {
Entry[] tab = table;
int len = tab.length;
// 回圈清理
for (int j = 0; j < len; j++) {
Entry e = tab[j];
if (e != null && e.get() == null)
expungeStaleEntry(j);
}
}
關于Map的清理
ThreadLocalMap實作采用的是開放尋址法，它的實作本身應該是比較簡潔的，但是為了便于GC，內部節點采用了弱參考作為key，一旦陣列中節點的強參考被設定為了null，節點的key就會被gc自動回收，這樣導致了ThreadLocalMap的實作變得例外的復雜，為了防止記憶體泄漏，在get和set方法的時候不得不進行額外的清理，
Q 為什么需要清理？
A 不清理的話key被回收，但是value依舊會存在，并且難以被回收導致記憶體泄漏，
Q 為什么清理的時候會涉及到節點的移動？
A 因為在開放尋址法中，可能會有相同hash值的節點連續排在一起，當其中的一個或多個節點被回收后會造成同hash值的節點中間存在null節點，而我們get節點的時候會在碰到空節點的時候停止尋找，所以如果不進行一定的清理移動會導致部分節點永遠不會被查詢到，
ThreadLocal的實作
hashcode的實作
講完了ThreadLocalMap的實作原理，我們可以深深的體會到ThreadLocal的hashcode是多么的重要，如果hash值不能夠以合理的方式生成，導致資料的分布不均勻，ThreadLocalMap的效率將會非常的低下，
hashcode的實作:
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode =
new AtomicInteger();
private static final int HASH_INCREMENT = 0x61c88647;
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
ThreadLocal的hashcode實作代碼很簡短：每一個新的ThreadLocal的hash值都是在nextHashCode的基礎上增加0x61c88647，實作很簡單，但是很讓人迷惑，這個莫名其妙的魔數0x61c88647是什么？
0x61c88647是有斐波那契構造而成的黃金比例數字，經過實驗測驗，這個數字生成的hashcode可以很大程度的保證hash值能夠在陣列中均勻的分布，
get
public T get() {
// 獲取當前執行緒
Thread t = Thread.currentThread();
// 獲取當前執行緒的變數map
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();
}
set
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
// 如果map不為空，加入資料
if (map != null)
map.set(this, value);
else
// 否則新建map并放入第一個和資料
createMap(t, value);
}
總結
1、Thredlocal這個類可能對于很多人來說是一個常常會用到的類，但是未必所有人都會去關注他的內部實作，但是他的原始碼是比較值得去閱讀的，一來它的實作代碼相對其他的常用類很短，只有幾百行；二來它的實作很經典，經典的開放尋址法，經典的弱參考方便GC，可以說是很好的學習材料，這里我雖然對于整個Thredlocal的原始碼進行了完整的注釋解釋，但是它最值得細細品味的還是它的設計理念以及設計思路，這會對我們寫出優秀的代碼有著重要的作用，
2、注意：光理論是不夠的，在此免費贈送5大JAVA架構專案實戰教程及大廠面試題庫，有興趣的可以進裙 783802103獲取，沒基礎勿進哦！
本文的文字及圖片來源于網路加上自己的想法,僅供學習、交流使用,不具有任何商業用途,著作權歸原作者所有,如有問題請及時聯系我們以作處
最后
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/173497.html
標籤：Java
上一篇：面向物件(一)