ThreadLocal是一個本地線程副本變量工具類。主要用於將私有線程和該線程存放的副本對象做一個映射,各個線程之間的變量互不干擾,特別適用於各個線程依賴不通的變量值完成操作的場景。下面我們來詳細瞭解一下它吧
簡介
ThreadLocal是每個線程自己維護的一個存儲對象的數據結構,線程間互不影響實現線程封閉。一般我們通過ThreadLocal對象的get/set方法存取對象。
源碼分析
ThreadLocal的set方法源碼如下
public void set(T value) { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); // 根據當前線程獲得ThreadLocalMap對象 if (map != null) map.set(this, value); // 如果有則set else createMap(t, value); // 否則創建ThreadLocalMap對象 } ThreadLocalMap getMap(Thread t) { return t.threadLocals; } void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }
通過getMap方法,可見我們返回的map實際上是Thread對象的threadLocals屬性。而這個ThreadLocalMap就是用來存儲數據的結構。
ThreadLocalMap介紹
ThreadLocalMap是ThreadLocal的核心,定義在ThreadLocal類裏的內部類,他維護了一個Enrty數組。ThreadLocal存/取數據都是通過操作Enrty數組來實現的。
Enrty數組作爲一個哈希表,將對象通過開放地址方法散列到這個數組中。作爲對比,HashMap則是通過鏈表法將對象散列到數組中。
開放地址法就是元素散列到數組中的位置如果有衝突,再以某種規則在數組中找到下一個可以散列的位置,而在ThreadLocalMap中則是使用線性探測的方式向後依次查找可以散列的位置。
Enery介紹
Enery在這裏我們稱之爲元素,是散列表中維護的對象單元。
// 哈希映射表中的元素使用其引用字段作爲鍵(它始終是ThreadLocal對象)繼承WeakReference。 // 注意,null鍵(即entry.get()== null)表示不再引用該鍵,因此可以從表中刪除該元素。 // 這些元素在下面的代碼中稱爲“舊元素”。 // 這些“舊元素”就是髒對象,因爲存在引用不會被GC, // 爲避免內存泄露需要代碼裏清理,將引用置爲null,那麼這些對象之後就會被GC清理。 // 實際上後面的代碼很大程度上都是在描述如何清理“舊元素”的引用 static class Entry extends WeakReference<ThreadLocal<?>> { Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
到這裏可能有兩個疑問
1、既然要存儲的內容是線程獨有的對象,爲什麼不直接在Thread裏設置一個屬性直接存儲該對象?或者說爲什麼要維護一個Entry散列表來存儲內容並以ThreadLocal對象作爲key?
答:一個ThreadLocal對象只屬於一個線程,但一個線程可以實例化ThreadLocal對象。而ThreadLocalMap維護的數組存儲的就是以ThreadLocal實例作爲key的Entry對象。
2、ThreadLocalMap中的Enery爲什麼要繼承WeakReference?
答:首先弱引用會在ThreadLocal對象不存在強引用的情況,弱引用對象會在下次GC時被清除。
將ThreadLocal對象作爲弱引用目的是爲了防止內存泄露。
假設Enery的key不是弱引用,即使在我們的代碼裏threadLocal引用已失效,threadLocal也不會被GC,因爲當前線程持有ThreadLocalMap的引用,而ThreadLocalMap持有Entry數組的引用,Entry對象的key又持有threadLocal的引用,threadLocal對象針對當前線程可達,所以不會被GC。
而Enery的key值threadLocal作爲弱引用,在引用失效時會被GC。但即使threadLocal做爲弱引用被GC清理,Entry[]還是存在entry對象,只是key爲null,vlue對象也還存在,這些都是髒對象。弱引用不單是清理了threadLocal對象,它的另一層含義是可以標識出Enery[]數組中哪些元素應該被GC(我們這裏稱爲舊元素),然後程序裏找出這些entry並清理。
ThreadLocalMap的set方法
回到前面提到的set方法,當map不爲null時會調用ThreadLocalMap的set方法。
ThreadLocalMap的set方法描述瞭如何將值散列到哈希表中,是開放地址法以線性探測方式散列的實現。在成功set值之後,嘗試清理一些舊元素,如果沒有發現舊元素則判斷閾值,確認哈希表是否足夠大、是否需要擴容。如果哈希表過於擁擠,get/set值會發生頻繁的衝突,這是不期望的情況。ThreadLocalMap的set方法代碼及詳細註釋如下
private void set(ThreadLocal<?> key, Object value) { // We do not use a fast path as with get() because it is at // least as common to use set() to create new entries as // it is to replace existing ones, in which case, a fast // path would fail more often than not. // 我們不像get()那樣先使用快速路徑(直接散列)判斷 // 因爲使用set()創建新元素至少與替換現有元素一樣頻繁,在這種情況下,散列後立刻判斷會容易失敗。 // 所以直接先線性探測 Entry[] tab = table; int len = tab.length; // 根據hashcode散列到數組位置 int i = key.threadLocalHashCode & (len-1); // 開放地址法處理散列衝突,線性探測找到可以存放位置 // 遍歷數組找到下一個可以存放元素的位置,這種位置包含三種情況 // 1.元素的key已存在,直接賦值value // 2.元素的key位null,說明k作爲弱引用被GC清理,該位置爲舊數據,需要被替換 // 3.直到遍歷到一個數組位置爲null的位置賦值 for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); if (k == key) {//key已存在則直接更新 e.value = value; return; } if (k == null) { //e不爲null但k爲null說明k作爲弱引用被GC,是舊數據需要被清理 // i爲舊數據位置,清理該位置並依據key合理地散列或將value替換到數組中 // 然後重新散列i後面的元素,並順便清理i位置附近的其他舊元素 replaceStaleEntry(key, value, i); return; } } // 遍歷到一個數組位置爲null的位置賦值 tab[i] = new Entry(key, value); int sz = ++size; // 調用cleanSomeSlots嘗試性發現並清理舊元素,如果沒有發現且舊元素當前容量超過閾值,則調用rehash if (!cleanSomeSlots(i, sz) && sz >= threshold) // 此時認爲表空間不足,全量遍歷清理舊元素,清理後判斷容量若大於閾值的3/4,若是則擴容並從新散列 rehash(); }
replaceStaleEntry方法
replaceStaleEntry方法是當我們線性探測時,如果碰到了舊元素就執行。該方法做的事情比較多,可以總結爲我們在staleSlot位置發現舊元素,將新值覆蓋到staleSlot位置上並清理staleSlot附近的舊元素。“附近”指的是staleSlot位置前後連續的非null元素。代碼及詳細註釋如下
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) { Entry[] tab = table; int len = tab.length; Entry e; // Back up to check for prior stale entry in current run. // We clean out whole runs at a time to avoid continual // incremental rehashing due to garbage collector freeing // up refs in bunches (i.e., whenever the collector runs). // 向前檢查是否存在舊元素,一次性徹底清理由於GC清除的弱引用key導致的舊數據,避免多次執行 int slotToExpunge = staleSlot; // 向前遍歷找到entry不爲空且key爲null的位置賦值給slotToExpunge for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) if (e.get() == null) slotToExpunge = i; // Find either the key or trailing null slot of run, whichever // occurs first // staleSlot位置向後遍歷如果位置不爲空,判斷key是否已經存在 // 回想前面我們是set實例的時候,碰到舊元素的情況下調用該方法,所以很可能在staleSlot後面key是已經存在的 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); // If we find key, then we need to swap it // with the stale entry to maintain hash table order. // The newly stale slot, or any other stale slot // encountered above it, can then be sent to expungeStaleEntry // to remove or rehash all of the other entries in run. // 如果我們找到鍵,那麼我們需要將它與舊元素交換以維護哈希表順序。 // 然後可以將交換後得到的舊索引位置 // 或其上方遇到的任何其他舊索引位置傳給expungeStaleEntry清理舊條 // 如果碰到key相同的值則覆蓋value if (k == key) { e.value = value; // i位置與staleSlot舊數據位置做交換,將數組元素位置規範化,維護哈希表順序 // 這裏維護哈希表順序是必要的,舉例來說,回想前面threadLocal.set實例的判斷,是線性探測找到可以賦值的位置 // 如果哈希順序不維護,可能造成同一個實例被賦值多次的情況 // 包括後面清理舊元素的地方都要重新維護哈希表順序 tab[i] = tab[staleSlot]; tab[staleSlot] = e; // Start expunge at preceding stale entry if it exists // 開始清理前面的舊元素 // 如果前面向前或向後查找的舊元素不存在,也就是slotToExpunge == staleSlot //此時slotToExpunge = i,此時位置i的元素是舊元素,需要被清理 // slotToExpunge用來存儲第一個需要被清理的舊元素位置 if (slotToExpunge == staleSlot) slotToExpunge = i; // 清理完slotToExpunge位置及其後面非空連續位置後,通過調用cleanSomeSlots嘗試性清理一些其他位置的舊元素 // cleanSomeSlots不保證清理全部舊元素,它的時間複雜度O(log2n),他只是全量清理舊元素或不清理的折中 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } // If we do not find stale entry on backward scan, the // first stale entry seen while scanning for key is the // first still present in the run. // 如果前面向前查找的舊元素不存在,也就是slotToExpunge == staleSlot,而此時位置i爲舊元素,所以將i賦值給slotToExpunge // slotToExpunge用來存儲第一個需要被清理的舊元素位置 if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // If key not found, put new entry in stale slot // 如果向後遍歷非空entry都沒有找到key,則直接賦值給當前staleSlot舊元素位置 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them // 通過前面根據staleSlot向前/向後遍歷,如果發現有舊元素則清理 if (slotToExpunge != staleSlot) // 清理完slotToExpunge位置及其後面非空連續位置後,通過調用cleanSomeSlots嘗試性清理一些其他位置的舊元素 // cleanSomeSlots不保證清理全部舊元素,它的時間複雜度O(log2n),他只是全量清理舊元素或不清理的折中 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); }
expungeStaleEntry方法
查找到的舊元素都會執行expungeStaleEntry方法。expungeStaleEntry頻繁被使用,它是清理舊元素的核心方法。該方法的做的事情就是:清理包括staleSlot位置後面連續爲空元素中的所有舊元素並重新散列,返回staleSlot後面首個null位置。代碼及詳細註釋如下
private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // expunge entry at staleSlot // 清空staleSlot位置的元素 tab[staleSlot].value = null; tab[staleSlot] = null; size--; // Rehash until we encounter null // 舊位置清理後,後面的元素需要重新散列到數組裏,直到遇到數組位置爲null。即維護哈希順序。 Entry e; int i; for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); if (k == null) { // k == null說明此位置也是舊數據,需要清理 e.value = null; tab[i] = null; size--; } else { int h = k.threadLocalHashCode & (len - 1); // 將staleSlot後面不爲空位置重新散列,如果與當前位置不同,則向前移動到h位置後面(包括h)的首個空位置 if (h != i) { tab[i] = null; // Unlike Knuth 6.4 Algorithm R, we must scan until // null because multiple entries could have been stale. while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i; }
cleanSomeSlots方法
cleanSomeSlots是一個比較靈動的方法。就如他的名字"some"一樣。該方法只是嘗試性地尋找一些舊元素。添加新元素或替換舊元素時都會調用此方法。它的執行複雜度log2(n),他是 “不清理”和“全量清理”的折中。若有發現舊元素返回true。代碼及詳細註釋如下
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); } // n >>>= 1無符號右移1位,即移動次數以n的二進制最高位的1的位置爲基準 // 所以時間複雜度log2(n) } while ( (n >>>= 1) != 0); return removed; }
rehash/expungeStaleEntries/resize方法
在成功set值後,通過閾值判斷,如果程序認爲表空間不足就會調用rehash方法。
rehash做了兩件事,首先全量遍歷清理舊元素,然後在清理後判斷容量是否足夠,若成立則2倍擴容並重新散列。
expungeStaleEntries則是全量清理舊元素,resize則是二倍擴容。
// rehash全量地遍歷清理舊元素,然後判斷容量若大於閾值的3/4,則擴容並從新散列 // 程序認爲表空間不足時會調用該方法 private void rehash() { // 全量遍歷清理舊元素 expungeStaleEntries(); // Use lower threshold for doubling to avoid hysteresis // 適當的擴容,以避免hash散列到數組時過多的位置衝突 if (size >= threshold - threshold / 4) // 2倍擴容並重新散列 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); } } // 二倍擴容 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) { e.value = null; // Help the GC } 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; }
ThreadLocal的get方法
ThreadLocal的get邏輯相比set要簡單的多。他只是將threadLocal對象散列到數組中,通過線性探測的方式找到匹配的值。代碼及詳細註釋如下
public T get() { Thread t = Thread.currentThread(); 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; } } // 如果map不爲null初始化一個key爲當前threadLocal值爲null的ThreadLocalMap對象 return setInitialValue(); } private Entry getEntry(ThreadLocal<?> key) { int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; if (e != null && e.get() == key) return e; else // 直接散列找不到的情況,調用getEntryAfterMiss線性探測查找期望元素 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) return e; if (k == null) expungeStaleEntry(i); else i = nextIndex(i, len); e = tab[i]; } return null; }
remove方法
remove即將引用清空並調用清理舊元素方法。所以remove不會產生舊元素,當我們確認哪些內容需要移除時優先使用remove方法清理,儘量不要交給GC處理。避免get/set發現舊元素的情況過多。
public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null) m.remove(this); } private void remove(ThreadLocal<?> key) { 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)]) { if (e.get() == key) { e.clear(); expungeStaleEntry(i); return; } } }
總結
ThreadLocal最大的複雜性在於如何處理舊元素,目的是爲了避免內存泄露。
在新增或替換元素成功後,爲了儘可能少地在get/set時發現有舊元素的情況,在清理舊元素後多次調用cleanSomeSlots嘗試性地發現並清理一些舊元素,爲了執行效率,“cleanSome”是“no clean” 不清理和“clean all”全量清理之間一的種平衡。
expungeStaleEntry在清理自己位置上的舊元素的同時也會清理附近的舊元素,爲得都是減少get/set發現舊元素的情況。即便如此,在哈希表容量過多時也會全量清理一遍舊元素並擴容。
當確認元素需要清除時,優先使用remove方法。
以上就是本文的全部內容,希望對大家的學習有所幫助,也希望大家多多支持神馬文庫。