ThreadLocal
先看一下一下官方的解釋：

/**
* This class provides thread-local variables. These variables differ from
* their normal counterparts in that each thread that accesses one (via its
* get or set method) has its own, independently initialized
* copy of the variable. ThreadLocal instances are typically private
* static fields in classes that wish to associate state with a thread (e.g.,
* a user ID or Transaction ID).
**/

我自己翻譯了一下：
ThreadLocal類提供了線程本地局部變量，這些局部變量區別于其他變量是因為，每一個線程都會有它自己的值，這個變量會在每一個線程中獨立進行初始化。ThreadLocal實例通常都是私有靜態的，這樣做是希望將狀態與線程聯系起來。

/** Each thread holds an implicit reference to its copy of a thread-local
* variable as long as the thread is alive and the ThreadLocal
* instance is accessible; after a thread goes away, all of its copies of
* thread-local instances are subject to garbage collection (unless other
* references to these copies exist).
**/
每一個線程都隱士的引用著他自己的線程本地變量的副本，只要線程一直存活并且ThreadLocal實例可以訪問。線程消失之后，所有的它自己的本地線程實例靠背對象都將會被回收（除非還有其他引用指向著這些副本）。

按照官方這兩段說明，大概意思是說ThreadLocal提供了一種能力：一個變量在多線程中都具有相同的初值，并且都存在于各自線程中彼此獨立互不影像、并且只要在同一線程中訪問都是同一個變量。當線程結束后，該變量也會被回收。

下面介紹一下ThreadLocal源碼：

/** * ThreadLocals rely on per-thread linear-probe hash maps attached * to each thread (Thread.threadLocals and * inheritableThreadLocals). The ThreadLocal objects act as keys, * searched via threadLocalHashCode. This is a custom hash code * (useful only within ThreadLocalMaps) that eliminates collisions * in the common case where consecutively constructed ThreadLocals * are used by the same threads, while remaining well-behaved in * less common cases. */ /** * ThreadLocal依靠線性探測哈希表附著到每個Thread. * ThreadLocal對象都使用threadLocalHashCode來進行區分。 * 這是一個自定義的哈希值（僅用在ThreadLocalMaps內部），用來區分在 * 同一個線程中連續構造的多個ThreadLocal對象。 */ /** * threadLocalHashCode 在set、get、remove方法中都是將這個值當做key進行查找 */ private final int threadLocalHashCode = nextHashCode();public ThreadLocal(); protected T initialValue(); T get(); void set(T value); void remove();

下面介紹一下簡單示例用法：

public class ThreadLocalTestActivity extends FragmentActivityRoot {private static final ThreadLocalTest threadLocalTest = new ThreadLocalTest();public static TestBean getTestBean() {TestBean testBean = threadLocalTest.get();if (testBean == null) {testBean = new TestBean();threadLocalTest.set(testBean);}return testBean;}private static class ThreadLocalTestRunable implements Runnable {@Overridepublic void run() {int count = 0;while(count < 10) {getTestBean().testInt += 100;try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.printf(Thread.currentThread().getName()+ ": threadLocal=%d\n", getTestBean().testInt);count++;}}}@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_test_thread_local);for( int i = 0;i < 2;i++) {Thread thread = new Thread(new ThreadLocalTestRunable());thread.start();}} }

日志如下：

d: fd=88
03-26 20:52:34.354 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=101
03-26 20:52:34.354 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=101
03-26 20:52:34.455 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=201
03-26 20:52:34.455 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=201
03-26 20:52:34.556 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=301
03-26 20:52:34.556 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=301
03-26 20:52:34.656 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=401
03-26 20:52:34.656 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=401
03-26 20:52:34.757 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=501
03-26 20:52:34.757 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=501
03-26 20:52:34.857 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=601
03-26 20:52:34.857 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=601
03-26 20:52:34.957 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=701
03-26 20:52:34.957 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=701
03-26 20:52:35.059 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=801
03-26 20:52:35.060 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=801
03-26 20:52:35.162 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=901
03-26 20:52:35.165 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=901
03-26 20:52:35.264 8163-8592/com.dqs.shangri.testinstrumentation I/System.out: Thread-5: threadLocal=1001
03-26 20:52:35.266 8163-8593/com.dqs.shangri.testinstrumentation I/System.out: Thread-6: threadLocal=1001

可以看到每個線程都有自己的TestBean 對象。每個線程在調用getTestBean()時都是返回的同一個對象。
為什么會有如此特性呢，就要分析get和set源碼。

先來介紹一些T get()方法：

public T get() {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);//第一次調用時，map為nullif (map != null) {ThreadLocalMap.Entry e = map.getEntry(this);if (e != null)return (T)e.value;}//1 設置初始值return setInitialValue(); }/*** Variant of set() to establish initialValue. Used instead* of set() in case user has overridden the set() method.** @return the initial value*/ private T setInitialValue() {T value = initialValue();Thread t = Thread.currentThread();//2 getMap第一次拿到的仍為nullThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);else {//3 創建mapcreateMap(t, value);}return value; }ThreadLocalMap getMap(Thread t) {return t.threadLocals; }//可復寫該方法。 protected T initialValue() {return null; }ThreadLocalMap getMap(Thread t) {return t.threadLocals; }void createMap(Thread t, T firstValue) {//4 到這就明朗了，第一次使用的時候，會給每個線程的threadLocals進行初始化，//類型為ThreadLocal.ThreadLocalMap//一次調用的firstValue來自T initialValue()；//如果沒有復寫該方法則為nullt.threadLocals = new ThreadLocalMap(this, firstValue); }

上面的第一次get調用路徑已經明了，
首先要拿到當前線程Thread，如果當前的線程的threadLocals為null，就創建一個。
其中創建的ThreadLocalMap的官方說法為：

/**
* Construct a new map initially containing (firstKey, firstValue).
* ThreadLocalMaps are constructed lazily, so we only create
* one when we have at least one entry to put in it.
*/
構造一個map,使用初始值（firstKey, firstValue）。ThreadLocalMaps 是懶加載的，
當我們即將要將entry 壓入到Map中時才進行創建。

也就是說ThreadLocalMap是一種map，通過key-value形式存儲我們給他的值。
也就是說每一個線程都有自己的ThreadLocalMap，key為ThreadLocal，value為任意Object。

現在先解釋一下ThreadLocalMap

/**
* ThreadLocalMap is a customized hash map suitable only for
* maintaining thread local values. No operations are exported
* outside of the ThreadLocal class. The class is package private to
* allow declaration of fields in class Thread. To help deal with
* very large and long-lived usages, the hash table entries use
* WeakReferences for keys. However, since reference queues are not
* used, stale entries are guaranteed to be removed only when
* the table starts running out of space.
*/
ThreadLocalMap 是一個定制的哈希map，僅適合用來維護線程本地值。
ThreadLocal 類外不能操作ThreadLocalMap 。
該類僅能在Thread class中使用。
用來解決非常大和長時間的引用，這些引用在哈希表內使用弱引用方式存儲。
然而，自從引用不被使用時，無用的條目會被刪除僅當表的空間將被耗盡的時候。

/*** The entries in this hash map extend WeakReference, using* its main ref field as the key (which is always a* ThreadLocal object). Note that null keys (i.e. entry.get()* == null) mean that the key is no longer referenced, so the* entry can be expunged from table. Such entries are referred to* as "stale entries" in the code that follows.*//*** 在當前哈希Map中的條目信息是繼承自弱引用，使用他的主引用作為key（在* 當前類中即為ThredLocal對象）。當keys為null的時候意味著不在被引用，* 所以這條就可以刪除。在之后的代碼中這類條目就稱為“stale entries”。*/ static class Entry extends WeakReference<ThreadLocal> {/** The value associated with this ThreadLocal. */Object value;Entry(ThreadLocal k, Object v) {super(k);value = v;} }//下面介紹ThreadLocalMap的成員變量 /*** The initial capacity -- MUST be a power of two.* 初始容量，一定必須是2的冪*/ private static final int INITIAL_CAPACITY = 16;/*** The table, resized as necessary.* table.length MUST always be a power of two.* table為存儲Entry的表，在必要的時候可以調整大小。* 表長一定為2的冪*/ private Entry[] table;/*** The number of entries in the table.* table表中存儲元素數量*/ private int size = 0;/*** The next size value at which to resize.* * 當達到threshold值的時候，進行resize*/ private int threshold; // Default to 0//介紹一下 構造方法 /*** Construct a new map initially containing (firstKey, firstValue).* ThreadLocalMaps are constructed lazily, so we only create* one when we have at least one entry to put in it.*/ ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {//table 為存儲Enrty的表結構，數組形式。容量必須為2的冪數。默認初始值為16table = new Entry[INITIAL_CAPACITY];//每一個ThreadLocal都有一個唯一的id 即threadLocalHashCode 。//通過與15做取余操作，找到當前ThreadLocal在table中的位置。int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);table[i] = new Entry(firstKey, firstValue);//更新table當前容量size = 1;//設置下次resize的目標值setThreshold(INITIAL_CAPACITY); }/*** Construct a new map including all Inheritable ThreadLocals* from given parent map. Called only by createInheritedMap.** 提供了一個可以初始table的構造方法，僅在createInheritedMap使用。* @param parentMap the map associated with parent thread.*/ private ThreadLocalMap(ThreadLocalMap parentMap) {Entry[] parentTable = parentMap.table;int len = parentTable.length;setThreshold(len);table = new Entry[len];//方法中介紹了，當散列表map中遇到沖突時的解決辦法，//該處使用的是開放定址法。后文會介紹該方法。for (int j = 0; j < len; j++) {Entry e = parentTable[j];if (e != null) {ThreadLocal key = e.get();if (key != null) {Object value = key.childValue(e.value);Entry c = new Entry(key, value);int h = key.threadLocalHashCode & (len - 1);//因為使用開放定址法，所以h會一直向后尋找。所以table為數組形式。while (table[h] != null)h = nextIndex(h, len);table[h] = c;size++;}}} }//下面介紹ThreadLocalMap的get方法 /*** Get the entry associated with key. This method* itself handles only the fast path: a direct hit of existing* key. It otherwise relays to getEntryAfterMiss. This is* designed to maximize performance for direct hits, in part* by making this method readily inlinable.** 通過key可以獲得相關的enrty。方法本身只處理快速路徑：直接通過存在的key進行尋找。* 如果找不到則會跳轉到getEntryAfterMiss中。這種辦法是為了能以最優的性能找到目標，* 因為大部分是可以通過改法直接找到。* * @param key the thread local object* @return the entry associated with key, or null if no such*/ private Entry getEntry(ThreadLocal key) {//首先通過key.threadLocalHashCode 和表長取余，找到位置int i = key.threadLocalHashCode & (table.length - 1);Entry e = table[i];if (e != null && e.get() == key)return e;else {//如果沒有找到e,或者key不相等，則通過getEntryAfterMiss查找return getEntryAfterMiss(key, i, e);} }/*** Version of getEntry method for use when key is not found in* its direct hash slot.* 如果在直接散列表中沒有通過key找到，將調用該方法。** @param key the thread local object* @param i the table index for key's hash code* @param e the entry at table[i]* @return the entry associated with key, or null if no such*/ 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) {// 如果找到的entry的key被收回，則進行回收entry操作。expungeStaleEntry(i);} else {//因為使用開放地址法，直接向后尋找i = nextIndex(i, len);}e = tab[i];//直到找到空位置時，return null;}return null; }/*** Expunge a stale entry by rehashing any possibly colliding entries* lying between staleSlot and the next null slot. This also expunges* any other stale entries encountered before the trailing null. See* Knuth, Section 6.4* * 在遇到沖突操作時，都會進行移除無用entry操作。移除范圍為當前位置到下一個null直接。* * * @param staleSlot index of slot known to have null key* @return the index of the next null slot after staleSlot* (all between staleSlot and this slot will have been checked* for expunging).*/ private int expungeStaleEntry(int staleSlot) {Entry[] tab = table;int len = tab.length;// expunge entry at staleSlottab[staleSlot].value = null;tab[staleSlot] = null;size--;// Rehash until we encounter nullEntry e;int i;for (i = nextIndex(staleSlot, len);(e = tab[i]) != null;i = nextIndex(i, len)) {ThreadLocal k = e.get();if (k == null) {e.value = null;tab[i] = null;size--;} else {int h = k.threadLocalHashCode & (len - 1);if (h != i) {//當刪除無用元素后，會對table中元素重新移動位置。以確保下次沖突查詢時，//能夠找到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; }//下面介紹set entry方法 /*** Set the value associated with key.** @param key the thread local object* @param value the value to be set*/ private void set(ThreadLocal key, Object value) {// We don't 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用來替換先用的，在這種情況下，通常就會失敗。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) {//如果當前entry的key相同，直接替換valuee.value = value;return;}if (k == null) {//如果當前位置的entry為staleEntry，則進行替換replaceStaleEntry(key, value, i);return;}}//如果沒有遇到staleEntry，則進行創建entrytab[i] = new Entry(key, value);int sz = ++size;//嘗試刪除無用對象，如果沒有刪除并且當前table數量已經大于等于threshold //將嘗試進行resizeif (!cleanSomeSlots(i, sz) && sz >= threshold)rehash(); }/*** Heuristically scan some cells looking for stale entries.* This is invoked when either a new element is added, or* another stale one has been expunged. It performs a* logarithmic number of scans, as a balance between no* scanning (fast but retains garbage) and a number of scans* proportional to number of elements, that would find all* garbage but would cause some insertions to take O(n) time.** @param i a position known NOT to hold a stale entry. The* scan starts at the element after i.** @param n scan control: <tt>log2(n)</tt> cells are scanned,* unless a stale entry is found, in which case* <tt>log2(table.length)-1</tt> additional cells are scanned.* When called from insertions, this parameter is the number* of elements, but when from replaceStaleEntry, it is the* table length. (Note: all this could be changed to be either* more or less aggressive by weighting n instead of just* using straight log n. But this version is simple, fast, and* seems to work well.)** 當添加新元素或者有其他的無用元素被刪除時會調用該方法啟發性的進行刪除無用元素。* 將以對數形式進行探索，目的為了到達一種平衡介于不進行探索和多次掃描之間。* 這樣做可以找到所有清除對象并且只使用O(n)的時間。* * @return true if any stale entries have been removed.*/ 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;//找到無用entry,即進行刪除i = expungeStaleEntry(i);}//n無符號右移} while ( (n >>>= 1) != 0);//如果刪除了返回truereturn removed; }/** * Re-pack and/or re-size the table. First scan the entire * table removing stale entries. If this doesn't sufficiently * shrink the size of the table, double the table size. */ private void rehash() {//遍歷整個Table，刪除所有無用對象。expungeStaleEntries();// Use lower threshold for doubling to avoid hysteresis// 如果size大于等于3/4 threshold，即進行resizeif (size >= threshold - threshold / 4)resize(); }/*** Expunge all stale entries in the table.* 刪除所有無用對象*/ 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);} }/*** Double the capacity of the table.* double表的容量*/ 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; }/*** Replace a stale entry encountered during a set operation* with an entry for the specified key. The value passed in* the value parameter is stored in the entry, whether or not* an entry already exists for the specified key.* * 在進行set操作時，通過key找到的插入位置為無效條目時，進行替換。* 無輪key所指向的條目是否存在，都會存儲通過參數傳進來的value。* * As a side effect, this method expunges all stale entries in the* "run" containing the stale entry. (A run is a sequence of entries* between two null slots.)* * 該方法有一個副作用，方法會刪除在run中的所有無效條目。* run的意思是指在兩個空槽之間的所有條目。* * @param key the key* @param value the value to be associated with key* @param staleSlot index of the first stale entry encountered while* searching for key.*/ 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).int slotToExpunge = staleSlot;//找到距離當前插入位置最近的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 firstfor (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.if (k == key) {e.value = value;tab[i] = tab[staleSlot];tab[staleSlot] = e;// Start expunge at preceding stale entry if it existsif (slotToExpunge == staleSlot)slotToExpunge = i;cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);return;}// If we didn't find stale entry on backward scan, the// first stale entry seen while scanning for key is the// first still present in the run.if (k == null && slotToExpunge == staleSlot)slotToExpunge = i;}// If key not found, put new entry in stale slottab[staleSlot].value = null;tab[staleSlot] = new Entry(key, value);// If there are any other stale entries in run, expunge themif (slotToExpunge != staleSlot)cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); }

散列表 開放定址法 具體介紹請跳轉此處
散列表解決沖突的辦法

那么回頭來說get方法：

public T get() {Thread t = Thread.currentThread();//再次調用時 map已經創建成功ThreadLocalMap map = getMap(t);if (map != null) {//根據map的getEntry可知，如果不遇到沖突，會很快找到元素，//如果遇到沖突會使用開放定址法來找到元素ThreadLocalMap.Entry e = map.getEntry(this);if (e != null)return (T)e.value;}return setInitialValue(); }/*** Remove the entry for key.* 刪除指定key找到的value*/ 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;}} }

當我們setEntry之后，如果遇到不再使用要主動remove。這樣可以達到性能最優。

總結一下：

ThreadLocal使用在多線程中，并且想要每一個線程中彼此獨立。那么使用ThreadLocal就是合適的。

ThreadLocal內部使用數組形式的哈希表，通過開放定址法解決沖突問題。

ThreadLocal 通常要定義成為：

private static ThreadLocal threadLocal;

可調用方法：

protected T initialValue(); //可以重寫該方法，賦值初始值 T get(); //使用該方法獲取值 void set(T value); //設置value void remove(); //不需要的時候remove

sy_dqs@163.com

總結

以上是生活随笔為你收集整理的小葵花妈妈课堂开课了：《ThreadLocal 浅析》的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。