文章目錄
接上一篇ThreadLocal源碼分析。
一、ThreadLocalMap實現思想
ThreadLocal類圖如下
ThreadLocal是一種存儲變量與線程綁定的方式,在每個線程中用自己的ThreadLocalMap安全隔離變量,實現線程封閉。
針對於ThreadLocal的底層實現原理,筆者在前一篇博客有詳細的介紹,並對源代碼中實現細節做了詳盡的分析。快速搞懂ThreadLocal實現原理
ThreadLocalMap是ThreadLocal內的一個Map實現,沒有實現任何接口,僅用於線程內部存儲ThreadLocal變量值。
static class ThreadLocalMap { ... }
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value; // ThreadLocal變量值
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
底層是Entry數組,Entry的key爲ThreadLocal,value是線程的該ThreadLocal變量值。Entry內部類繼承了WeakReference類。當entry.get()方法得到的ThreadLocal引用爲空,表示該key不再被引用,此時Entry對象視爲【過期】,在數組中刪除。
二、屬性與構造方法
屬性:
private Entry[] table; // 表,必須爲2的冪次方大小
private int size = 0; // 初始Entry數
private int threshold; // resize操作,元素個數閾值
// 負載因子固定爲2/3
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
構造方法:
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化大小爲16的Entry數組
table = new Entry[INITIAL_CAPACITY];
// 取模對應數組索引
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue); // 插入元素
size = 1; // 更新size
setThreshold(INITIAL_CAPACITY); // 設置resize閾值,此時爲10
}
三、核心方法
3.1 hashcode的計算
ThreadLocal變量與當前線程綁定,在HashMap中作爲key,通過threadLocalHashCode值來查找。
// 自定義hashcode,可以用來解決同一線程連續構造ThreadLocal對象引起的衝突。
private final int threadLocalHashCode = nextHashCode()
// 下一個hashCode值,原子更新,初始值爲0
private static AtomicInteger nextHashCode = new AtomicInteger();
// 返回下一個hashcode
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 魔數:相鄰兩個hashcode之間的偏移
// 對2的冪次方大小的表,產生近似最優的hash值
private static final int HASH_INCREMENT = 0x61c88647;
3.2 set()方法
設置ThreadLocal變量值。
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; // entry不爲空
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get(); // 獲取Entry的key--ThreadLocal
// 如果當前Entry的key與形參key相等,更新value值
if (k == key) {
e.value = value;
return;
}
// 如果當前Entry的key爲空,說明已過期,做清理!
if (k == null) {
// 清理過期Entry,繼續探索放置位置
replaceStaleEntry(key, value, i);
return;
}
}
// 若沒有找到對應key,則在空位置創建Entry
tab[i] = new Entry(key, value);
int sz = ++size; // 更新size
// 清理一些過期的位置,判斷是否需要擴容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
從set方法中,可以看出ThreadLocalMap中哈希衝突解決方法是開放地址法,而不是HashMap等採用鏈地址法。
前後索引位置–循環
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
3.3 getEntry()方法
根據ThreadLocal獲取對應Entry對象。
private Entry getEntry(ThreadLocal<?> key) {
// 根據hashcode計算直接hash索引
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 如果是找到並且是有效Entry對象,直接返回
if (e != null && e.get() == key)
return e;
else // 不是目標Entry
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();
if (k == key) // 找到目標Entry
return e;
if (k == null) // 清理過期Entry
expungeStaleEntry(i);
else // 當前位置是有效Entry,索引右移
i = nextIndex(i, len);
e = tab[i];
}
return null; // 找不到,返回null
}
3.4 remove()方法
移除ThreadLocal變量對應的Entry對象。
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
// 遍歷找到指定key的Entry對象
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
if (e.get() == key) {
e.clear(); // 清理引用
expungeStaleEntry(i); // 清理過期Entry
return;
}
}
}
3.5 rehash()方法
private void rehash() {
// 清理table中所有過期Entry對象。
expungeStaleEntries();
// 如果元素個數超過閾值的3/4時,進行擴容
// 注:閾值本身是數組長度的2/3
if (size >= threshold - threshold / 4)
resize();
}
// 擴容至原容量的2倍
private void resize() {
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) {
ThreadLocal<?> k = e.get();
if (k == null) { // 過期Entry,清空value
e.value = null; // 利於垃圾回收
} else {
// 計算索引
int h = k.threadLocalHashCode & (newLen - 1);
// 如果直接hash索引位置不爲空,繼續向後探索
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen); // 更新閾值
size = count;
table = newTab;
}
3.6 對於清理過期數據的關鍵實現方法
1. replaceStaleEntry()方法
清理過期Entry,設置輸入鍵值對。
// staleSlot:key == null的位置
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
// 從前一個位置開始向前尋找過期Entry,直到entry不爲空
// 不斷向前移動清理位置
int slotToExpunge = staleSlot; // 清理元素的最開始位置
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null; // entry不爲空
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// 從後一個位置向後探索
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null; // entry不爲空
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// 如果找到key,需要將它與過期位置元素做交換,來維持哈希表順序。
if (k == key) {
e.value = value; // 更新value
tab[i] = tab[staleSlot]; // 元素交換
tab[staleSlot] = e;
// 如果相等,表示向前遍歷時沒有找到key爲null的元素
// 前面語句進行了元素交換,此時位置i之前的元素均不需要清理
if (slotToExpunge == staleSlot)
slotToExpunge = i; // 更新清理開始位置
// 從slotToExpunge位置清理過期Entry(key == null)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// 如果遍歷中找到key爲null的元素,並且向前沒有找到key爲null的位置
// 更新清理開始位置slotToExpunge爲當前位置i
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 如果沒找到key,新建Entry發在staleSlot位置
tab[staleSlot].value = null; // 清理動作
tab[staleSlot] = new Entry(key, value);
// 如果除了staleSlot位置,還有其他位置元素要清理(key == null的Entry)
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
【注】slotToExpunge變量記錄着元素清理的最開始位置。
2. cleanSomeSlots方法
嘗試掃描一些過期元素的位置,當添加新元素、清理其他過期元素時被調用。
從i位置開始掃描,i位置不是過期元素。而參數n用來限制掃描次數,如果過期Entry沒有發現,可以掃描log(n)次,log(n)的設定出於性能的考慮。
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==null的Entry
if (e != null && e.get() == null) {
n = len; // 重置n
removed = true; // 標誌有清理元素
i = expungeStaleEntry(i); // 清理
}
} while ( (n >>>= 1) != 0); // log(n) 限制--對數次
return removed;
}
3. expungeStaleEntry(int staleSlot) 方法
作用:從staleSlot位置開始,清理key爲null的Entry,直到entry爲null的位置。過程中,遇到的entry不爲空,並且entry.get()不爲空的元素,進行rehash重新確定該元素位置。
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 清理staleSlot位置的Entry對象
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// rehash直到entry爲null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null; // entry不爲null
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) { // 過期Entry,處理方式同staleSlot
e.value = null;
tab[i] = null;
size--;
} else {
// rehash計算出當前Entry索引
int h = k.threadLocalHashCode & (len - 1);
if (h != i) { // 不相等,說明原位置是探測出的。
tab[i] = null; // 原位置對象置空
// 如果h索引位置不爲null,向後探測,直到找到null位置
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i; // i位置 (entry = tab[i]) == null
}