Java併發編程的學習過程當中，必定繞不過ThreadLocal，在實際開發中，ThreadLocal的應用場景仍是很豐富的：java

線程間數據的隔離。
Session的管理。
事務的管理。
參數的隱式傳遞(PageHelper)。
Dubbo的RpcContext。

爲了更好的理解ThreadLocal原理，筆者記錄一下源碼閱讀的過程，錯誤之處，還望讀者指出，不勝感激。算法

源碼解析

一、threadLocalHashCode ThreadLocal實例會被當作Key存放到Thread的ThreadLocalMap中，所以須要根據ThreadLocal的hashCode計算一個下標，還要解決哈希衝突等問題。ThreadLocalMap並非根據hashCode()方法來計算哈希值，而是用了一套遞增的規則：編程

/* ThreadLocal實例會被當作Key存放到Thread的ThreadLocalMap中。 須要根據hashCode來計算下標。 這裏並無調用hashCode()方法，而是根據0x61c88647的步長一直遞增計算的。 */
private final int threadLocalHashCode = nextHashCode();

// 經過CAS的方式來生成hashCode
private static AtomicInteger nextHashCode =
		new AtomicInteger();

// hashCode遞增的步長，爲何是這個數？https://zhuanlan.zhihu.com/p/40515974
private static final int HASH_INCREMENT = 0x61c88647;

// 計算下一個hashCode，一直遞增
private static int nextHashCode() {
	return nextHashCode.getAndAdd(HASH_INCREMENT);
}
複製代碼

遞增的步長爲何是0x61c88647？ ThreadLocalMap底層是用Entry[]實現的，和HashMap同樣，這個數組的長度無論如何擴容，始終都會是2的N次方，以0x61c88647爲步長作遞增，可讓hashCode更加均勻的分佈在2的N次方的數組裏。具體能夠參考：從 ThreadLocal 的實現看散列算法。數組

二、set()作了什麼？ 當線程調用ThreadLocal的set()方法時，它首先會獲取當前線程的ThreadLocalMap，若是爲null，則建立一個ThreadLocalMap，不然往ThreadLocalMap裏put元素。markdown

/* 1.獲取當前線程的ThreadLocalMap 2.爲null則建立，並set 3.不爲null則直接set */
public void set(T value) {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null)
		map.set(this, value);
	else
		createMap(t, value);
}
複製代碼

一個新的線程首次set()時，會建立一個ThreadLocalMap：併發

/* 給Thread的threadLocals建立Map實例，並添加元素。 */
void createMap(Thread t, T firstValue) {
	t.threadLocals = new ThreadLocalMap(this, firstValue);
}
複製代碼

ThreadLocalMap ThreadLocalMap是ThreadLocal的靜態內部類，底層採用Entry[]數組來保存數據。和HashMap不一樣的是，遇到哈希衝突時，Entry並不會轉換爲鏈表或紅黑樹，而是採用開放定址法的線性探測來實現的。關於哈希衝突的處理方式有哪些，能夠看筆者的另外一篇文章：哈希衝突的常看法決方式。oop

// 初始化ThreadLocalMap實例
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
	// 初始化，默認容量16
	table = new Entry[INITIAL_CAPACITY];
	// 計算下標，算法：hashCode & (len - 1)，和HashMap同樣，這裏不詳敘。
	int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
	table[i] = new Entry(firstKey, firstValue);
	size = 1;
	// 設置擴容閾值:容量的三分之二
	setThreshold(INITIAL_CAPACITY);
}

private void setThreshold(int len) {
	threshold = len * 2 / 3;
}
複製代碼

Entry Entry繼承自WeakReference，它的Key是一個弱引用，使用的時候須要注意，儘量的去手動執行remove()，以避免發生內存泄漏。性能

/* Entry的Key是弱引用。 當ThreadLocal實例外部不存在強引用時，GC就會將其回收掉。 若是沒有調用remove()，value就仍然還有引用，無法回收。 這時就容易致使內存泄漏。 */
static class Entry extends WeakReference<ThreadLocal<?>> {
	Object value;

	Entry(ThreadLocal<?> k, Object v) {
		super(k);
		value = v;
	}
}
複製代碼

若是ThreadLocalMap不爲null時，則須要往裏面添加元素了：學習

private void set(ThreadLocal<?> key, Object value) {
	Entry[] tab = table;
	int len = tab.length;
	// 計算下標，算法：hashCode & (len - 1)，和HashMap同樣，這裏不詳敘。
	int i = key.threadLocalHashCode & (len-1);

	for (Entry e = tab[i];
		 /* 若是下標元素不是null，有兩種狀況: 1.同一個Key，覆蓋value。 2.哈希衝突了。 */
		 e != null;
		 /* 哈希衝突的解決方式:開放定址法的線性探測。 當前下標被佔用了，就找next，找到尾巴還沒找到就從頭開始找。 直到找到沒有被佔用的下標。 */
		 e = tab[i = nextIndex(i, len)]) {
		ThreadLocal<?> k = e.get();

		if (k == key) {
			// 相同的Key，則覆蓋value。
			e.value = value;
			return;
		}

		if (k == null) {
			/* 下標被佔用，可是Key.get()爲null。說明ThreadLocal被回收了。 須要進行替換。 */
			replaceStaleEntry(key, value, i);
			return;
		}
	}

	tab[i] = new Entry(key, value);
	int sz = ++size;
	/* 1.判斷是否能夠清理一些槽位。 2.若是清理成功，就無需擴容了，由於已經騰出一些位置留給下次使用。 3.若是清理失敗，則要判斷是否須要擴容。 */
	if (!cleanSomeSlots(i, sz) && sz >= threshold)
		rehash();
}
複製代碼

元素添加成功後，ThreadLocalMap會對元素中已經被回收的Key作清理工做。處於性能考慮，ThreadLocalMap並不會對全部的元素進行檢查，而是採樣部分數據。this

/* 清理部分槽位。 1.若是清理成功，就不用擴容了，由於已經騰出一部分位置了。 2.處於性能考慮，不會作全部元素作清理工做，而是採樣清理。 set()時，n=size，搜索範圍較小。 */
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，擴大搜索範圍
			n = len;
			removed = true;
			// 真正清理的邏輯
			i = expungeStaleEntry(i);
		}
		/* 採樣規則: n >>>= 1 (折半) 例:100 > 50 > 25 > 12 > 6 > 3 > 1 */
	} while ( (n >>>= 1) != 0);
	return removed;
}
複製代碼

若是找到了過時的Key，那就要進行清理工做了：

/* 刪除過時的元素:佔用下標，可是ThreadLocal實例已經被回收的元素。 */
private int expungeStaleEntry(int staleSlot) {
	Entry[] tab = table;
	int len = tab.length;

	// 清理當前Entry
	tab[staleSlot].value = null;
	tab[staleSlot] = null;
	size--;

	// Rehash until we encounter null
	Entry e;
	int i;
	// 繼續日後尋找，直到遇到null結束
	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) {
				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;
}
複製代碼

清理時，並非只清理掉當前Entry就結束了，而是會日後環形的繼續尋找過時的Entry，只要找到了就清理，直到遇到tab[i]==null就結束，清理的過程當中還會對元素作一個rehash的操做。

若是清理不成功，則要判斷size是否超過threshold閾值，若是超過，則要進行全量的清理工做和判斷是否擴容。

private void rehash() {
	// 全量清理過時Entry
	expungeStaleEntries();

	// 清理後，若是size依然超過閾值的四分之三，則要擴容
	if (size >= threshold - threshold / 4)
		resize();
}
複製代碼

全量清理過時Entry：

// 全量清理過時Entry
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);
	}
}
複製代碼

清理後，若是size依然超過閾值的四分之三，則要擴容：

// 擴容規則:雙倍擴容
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;
}
複製代碼

至此，Set()的邏輯所有結束。

三、get()作了什麼？ get()獲取Value時，首先會判斷當前線程的ThreadLocalMap是否爲null，若是爲null，則會調用initialValue()得到一個初始值，並set()到ThreadLocalMap中。

/* 獲取Value時: 1.獲取當前線程的ThreadLocalMap 2.若是爲null，則建立Map並設置初始值。 3.不爲null，則經過Map查找。 */
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;
		}
	}
	return setInitialValue();
}
複製代碼

若是ThreadLocalMap不爲null，則要開始查找了：

/* 經過Key獲取Entry */
private Entry getEntry(ThreadLocal<?> key) {
	// 計算下標
	int i = key.threadLocalHashCode & (table.length - 1);
	Entry e = table[i];
	if (e != null && e.get() == key) {
		// 若是對應下標節點不爲null，且Key相等，則命中直接返回
		return e;
	} else {
		/* 不然有兩種狀況: 1.Key不存在。 2.哈希衝突了，須要向後環形查找。 */
		return getEntryAfterMiss(key, i, e);
	}
}
複製代碼

命中則直接返回，不命中有兩種狀況:

Key不存在。
哈希衝突了，須要向後環形查找。

/* 沒法直接命中的查找邏輯 */
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
	Entry[] tab = table;
	int len = tab.length;

	while (e != null) {// e==null說明Key不存在，直接返回null
		ThreadLocal<?> k = e.get();
		if (k == key)
			// 找到了，說明是哈希衝突
			return e;
		if (k == null)
			// Key存在，可是過時了，須要清理掉，而且返回null
			expungeStaleEntry(i);
		else
			// 向後環形查找
			i = nextIndex(i, len);
		e = tab[i];
	}
	return null;
}
複製代碼

若是成功找到了Entry節點，則直接返回其value便可。

三、remove()作了什麼？ 獲取當前線程的ThreadLocalMap，並刪除元素。

// 找到當前線程的ThreadLocalMap，並刪除元素
public void remove() {
	ThreadLocalMap m = getMap(Thread.currentThread());
	if (m != null)
		m.remove(this);
}
複製代碼

主要邏輯在ThreadLocalMap.remove()裏：

// 經過Key刪除Entry
private void remove(ThreadLocal<?> key) {
	Entry[] tab = table;
	int len = tab.length;
	// 計算下標
	int i = key.threadLocalHashCode & (len-1);
	/* 刪除也是同樣，因爲存在哈希衝突，不能直接定位到下標後直接刪除。 刪除前須要確認Key是否相等，若是不等須要日後環形查找。 */
	for (Entry e = tab[i];
		 e != null;
		 e = tab[i = nextIndex(i, len)]) {
		if (e.get() == key) {
			/* 找到了就清理掉。 這裏並無直接清理，而是將Key的Reference引用清空了， 而後再調用expungeStaleEntry()清理過時元素。 順便還能夠清理後續節點。 */
			e.clear();
			expungeStaleEntry(i);
			return;
		}
	}
}
複製代碼

因爲哈希衝突的存在，因此不能定位到節點後直接刪除，須要確認Key是否相等，若是不等須要日後環形查找，直到找到正確的Key。

清理也不是簡單的直接置空，而是先將Key的引用置空，而後調用了expungeStaleEntry()方法清理過時的元素。這個過程會順帶清理後續的節點和rehash操做。

問題

一、爲何要使用弱引用？

每一個線程都有本身的ThreadLocalMap，若是ThreadLocalMap強引用了ThreadLocal，那麼即便咱們執行了ThreadLocal=null，ThreadLocal也沒法被回收，難道你想回收ThreadLocal時，遍歷全部線程，將全部線程的ThreadLocalMap的當前ThreadLocal進行remove操做？？？

正是因爲採用了弱引用，這才使得，只要ThreadLocal實例外部不存在強引用，GC時就能將其回收，ThreadLocalMap在進行一些讀寫操做時，也會去自發性的作一些過時檢查，刪除過時的Entry，最大程度的避免了內存泄漏。

二、爲何會內存泄漏？

ThreadLocalMap的弱引用只針對Key，若是ThreadLocal不存在強引用了，GC就會將其回收，可是Value因爲存在和Entry的強引用，所以不會被回收，這樣就會致使一些永遠也沒法被訪問的Value存在，即發生內存泄漏。

固然，針對這種狀況，JDK已經在儘可能去避免了。在對ThreadLocal進行讀寫時，有不少地方會觸發它執行過時檢查，刪除過時的Entry，避免內存泄漏。

三、何時會觸發過時檢查清理？

調用set()方法時，採樣清理、全量清理，擴容時還會繼續檢查。
調用get()方法，沒有直接命中，向後環形查找時。
調用remove()時，除了清理當前Entry，還會向後繼續清理。

四、如何避免內存泄漏

使用ThreadLocal時，通常建議將其聲明爲static final的，避免頻繁建立ThreadLocal實例。儘可能避免存儲大對象，若是非要存，那麼儘可能在訪問完成後及時調用remove()刪除掉。

ThreadLocal的Value會發生內存泄漏的狀況，可是JDK已經作了不少操做來避免。例如上面說的會在不少場景下自發的去清理過時的Entry，使得無效Value能夠被回收。通常來講正常使用不會有太大的問題，可能會致使部分Value會發生短暫的內存泄漏，可是在後續的過時檢查中，也是會被清理掉的。儘管如此，仍是建議你們及時調用remove()。

你可能感興趣的文章：

ThreadLocal源碼解析

源碼解析

問題

一、爲何要使用弱引用？

二、爲何會內存泄漏？

三、何時會觸發過時檢查清理？

四、如何避免內存泄漏