概述
ThreadLocalMap是ThreadLocal的內部類，是一個key-value資料形式結構，也是ThreadLocal的核心，
ThreadLocalMap中資料是存盤在Entry型別陣列的table中的，Entry繼承了WeakReference（弱參考），注意key是弱參考，vlaue不是，
原始碼解讀
1.成員變數
/**
* 初始容量
*/
private static final int INITIAL_CAPACITY = 16;
/**
* ThreadLocalMap資料真正存盤在table中
*/
private Entry[] table;
/**
* ThreadLocalMap條數
*/
private int size = 0;
/**
* 達到這個大小，則擴容
*/
private int threshold; // 默認為0
2.threadLocalHashCode
private final int threadLocalHashCode = nextHashCode();
private static AtomicInteger nextHashCode = new AtomicInteger();
/**
* The difference between successively generated hash codes - turns
* implicit sequential thread-local IDs into near-optimally spread
* multiplicative hash values for power-of-two-sized tables.
*/
private static final int HASH_INCREMENT = 0x61c88647;
/**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
HASH_INCREMENT = 0x61c88647是一個魔法數，可以減少hash沖突，通過nextHashCode.getAndAdd(HASH_INCREMENT)方法會轉化為二進制資料，主要作用是增加哈希值，減少哈希沖突
3.建構式
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//初始化table陣列，INITIAL_CAPACITY默認值為16
table = new Entry[INITIAL_CAPACITY];
//key和16取得哈希值
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//創建節點，設定key-value
table[i] = new Entry(firstKey, firstValue);
size = 1;
//設定擴容閾值
setThreshold(INITIAL_CAPACITY);
}
4.set
private void set(ThreadLocal<?> key, Object value) {
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();
if (k == key) {
//如果key是相同，則替換，并return
e.value = value;
return;
}
if (k == null) {
//e！=null，key==null，因為key是弱參考，所以key已經被gc回收了，replaceStaleEntry方法就是用來解決記憶體泄露問題
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
int slotToExpunge = staleSlot;
//prevIndex是指標向前，尋找前面過期資料
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
//向后尋找key相同的資料
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
//通過和過期的slot進行交換，維護哈希表順序
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
if (slotToExpunge == staleSlot)
slotToExpunge = i;
//清除過期slot
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 如果key并沒有在map中出現過，則直接創建
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
//如果還有其他過期slot，則清除
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
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];
if (e != null && e.get() == null) {
n = len;
removed = true;
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 洗掉下標為staleSlot的slot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// 重新哈希，直到遇到null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//如果key==null，說明已經被回收
if (k == null) {
//Entry設定為null，size減一
e.value = null;
tab[i] = null;
size--;
} else {
//重新進行hash計算
int h = k.threadLocalHashCode & (len - 1);
//如果計算的位置和從前位置不一致
if (h != i) {
tab[i] = null;
//掃描到null，將值放入
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
private void rehash() {
expungeStaleEntries();
//如果當前size大于法制的四分之三，則擴容
if (size >= threshold - threshold / 4)
resize();
}
/**
* 全域清理
*/
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);
}
}
set方法首先根據key計算存盤位置
如果計算出來的下標不為空，會進入回圈，回圈內如果key相同，則直接替換，如果key被回收，則呼叫replaceStaleEntry方法清除，并且在該方法中設定value，
如果計算出來的下標為空，則直接設定值，并在最后通過cleanSomeSlots清除過期key和確定是否通過rehash擴容，
5.getEntry
private Entry getEntry(ThreadLocal<?> key) {
//計算下標位置
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//沒有hash沖突，entry存在，并且key未被回收
if (e != null && e.get() == key)
return e;
else
//hash沖突，通過線性探測查找，可能查詢到
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
//回圈查找，直到為null
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;
}
getEntry是根據ThreadLocal獲取ThreadLocalMap中某個值的，如果存在哈希沖突則通過getEntryAfterMiss方法線性探測查找
6.remove
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
//如果threadLocalHashCode計算出的下標找到的key和傳入key不同，則證明出現哈希沖突，則回圈向下查找
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
//如果key相同
if (e.get() == key) {
//洗掉當前Entry
e.clear();
//清理
expungeStaleEntry(i);
return;
}
}
}
總結
1.ThreadLocalMap.Entry繼承了WeakReference，實作了弱參考，提高了垃圾回收的效率，
2.ThreadLocalMap可能存在記憶體泄露，因為key被回收后，但是value依然和Entry存在強參考關系，所以使用完進行remove是一個很好的習慣，可以避免記憶體泄露，
java物件強、軟、弱、虛四種參考
ThreadLocal使用及原理詳解
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/195033.html
標籤：其他