概述

相信讀者在網(wǎng)上也看了很多關(guān)于ThreadLocal的資料，很多博客都這樣說：ThreadLocal為解決多線程程序的并發(fā)問題提供了一種新的思路；ThreadLocal的目的是為了解決多線程訪問資源時的共享問題。如果你也這樣認(rèn)為的，那現(xiàn)在給你10秒鐘，清空之前對ThreadLocal的錯誤的認(rèn)知！看看JDK中的源碼是怎么寫的：

This class PRovides thread-local variables. These variables differ fromtheir normal counterparts in that each thread that accesses one (via its{@code get} or {@code set} method) has its own, independently initializedcopy of the variable. {@code ThreadLocal} instances are typically privatestatic fields in classes that wish to associate state with a thread (e.g.,a user ID or Transaction ID).

翻譯過來大概是這樣的(英文不好，如有更好的翻譯，請留言說明)：

ThreadLocal類用來提供線程內(nèi)部的局部變量。這種變量在多線程環(huán)境下訪問(通過get或set方法訪問)時能保證各個線程里的變量相對獨(dú)立于其他線程內(nèi)的變量。ThreadLocal實(shí)例通常來說都是private static類型的，用于關(guān)聯(lián)線程和線程的上下文。

可以總結(jié)為一句話：ThreadLocal的作用是提供線程內(nèi)的局部變量，這種變量在線程的生命周期內(nèi)起作用，減少同一個線程內(nèi)多個函數(shù)或者組件之間一些公共變量的傳遞的復(fù)雜度。舉個例子，我出門需要先坐公交再做地鐵，這里的坐公交和坐地鐵就好比是同一個線程內(nèi)的兩個函數(shù)，我就是一個線程，我要完成這兩個函數(shù)都需要同一個東西：公交卡（北京公交和地鐵都使用公交卡），那么我為了不向這兩個函數(shù)都傳遞公交卡這個變量（相當(dāng)于不是一直帶著公交卡上路），我可以這么做：將公交卡事先交給一個機(jī)構(gòu)，當(dāng)我需要刷卡的時候再向這個機(jī)構(gòu)要公交卡（當(dāng)然每次拿的都是同一張公交卡）。這樣就能達(dá)到只要是我(同一個線程)需要公交卡，何時何地都能向這個機(jī)構(gòu)要的目的。

有人要說了：你可以將公交卡設(shè)置為全局變量啊，這樣不是也能何時何地都能取公交卡嗎？但是如果有很多個人（很多個線程）呢？大家可不能都使用同一張公交卡吧(我們假設(shè)公交卡是實(shí)名認(rèn)證的)，這樣不就亂套了嘛。現(xiàn)在明白了吧？這就是ThreadLocal設(shè)計(jì)的初衷：提供線程內(nèi)部的局部變量，在本線程內(nèi)隨時隨地可取，隔離其他線程。

ThreadLocal基本操作

構(gòu)造函數(shù)

ThreadLocal的構(gòu)造函數(shù)簽名是這樣的：

123456

/** * Creates a thread local variable. * @see #withInitial(java.util.function.Supplier) */public ThreadLocal() {}

內(nèi)部啥也沒做。

initialValue函數(shù)

initialValue函數(shù)用來設(shè)置ThreadLocal的初始值，函數(shù)簽名如下：

123	protected T initialValue() { return null;}

該函數(shù)在調(diào)用get函數(shù)的時候會第一次調(diào)用，但是如果一開始就調(diào)用了set函數(shù)，則該函數(shù)不會被調(diào)用。通常該函數(shù)只會被調(diào)用一次，除非手動調(diào)用了remove函數(shù)之后又調(diào)用get函數(shù)，這種情況下，get函數(shù)中還是會調(diào)用initialValue函數(shù)。該函數(shù)是protected類型的，很顯然是建議在子類重載該函數(shù)的，所以通常該函數(shù)都會以匿名內(nèi)部類的形式被重載，以指定初始值，比如：

1234567891011121314

package com.winwill.test;/** * @author qifuguang * @date 15/9/2 00:05 */public class TestThreadLocal { private static final ThreadLocal<Integer> value = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return Integer.valueOf(1); } };}

get函數(shù)

該函數(shù)用來獲取與當(dāng)前線程關(guān)聯(lián)的ThreadLocal的值，函數(shù)簽名如下：

1	public T get()

如果當(dāng)前線程沒有該ThreadLocal的值，則調(diào)用initialValue函數(shù)獲取初始值返回。

set函數(shù)

set函數(shù)用來設(shè)置當(dāng)前線程的該ThreadLocal的值，函數(shù)簽名如下：

1	public void set(T value)

設(shè)置當(dāng)前線程的ThreadLocal的值為value。

remove函數(shù)

remove函數(shù)用來將當(dāng)前線程的ThreadLocal綁定的值刪除，函數(shù)簽名如下：

1	public void remove()

在某些情況下需要手動調(diào)用該函數(shù)，防止內(nèi)存泄露。

代碼演示

學(xué)習(xí)了最基本的操作之后，我們用一段代碼來演示ThreadLocal的用法，該例子實(shí)現(xiàn)下面這個場景：

有5個線程，這5個線程都有一個值value，初始值為0，線程運(yùn)行時用一個循環(huán)往value值相加數(shù)字。

代碼實(shí)現(xiàn)：

123456789101112131415161718192021222324252627282930313233343536

package com.winwill.test;/** * @author qifuguang * @date 15/9/2 00:05 */public class TestThreadLocal { private static final ThreadLocal<Integer> value = new ThreadLocal<Integer>() { @Override protected Integer initialValue() { return 0; } }; public static void main(String[] args) { for (int i = 0; i < 5; i++) { new Thread(new MyThread(i)).start(); } } static class MyThread implements Runnable { private int index; public MyThread(int index) { this.index = index; } public void run() { System.out.println("線程" + index + "的初始value:" + value.get()); for (int i = 0; i < 10; i++) { value.set(value.get() + i); } System.out.println("線程" + index + "的累加value:" + value.get()); } }}

執(zhí)行結(jié)果為：

線程0的初始value:0線程3的初始value:0線程2的初始value:0線程2的累加value:45線程1的初始value:0線程3的累加value:45線程0的累加value:45線程1的累加value:45線程4的初始value:0線程4的累加value:45

可以看到，各個線程的value值是相互獨(dú)立的，本線程的累加操作不會影響到其他線程的值，真正達(dá)到了線程內(nèi)部隔離的效果。

如何實(shí)現(xiàn)的

看了基本介紹，也看了最簡單的效果演示之后，我們更應(yīng)該好好研究下ThreadLocal內(nèi)部的實(shí)現(xiàn)原理。如果給你設(shè)計(jì)，你會怎么設(shè)計(jì)？相信大部分人會有這樣的想法：

每個ThreadLocal類創(chuàng)建一個Map，然后用線程的ID作為Map的key，實(shí)例對象作為Map的value，這樣就能達(dá)到各個線程的值隔離的效果。

沒錯，這是最簡單的設(shè)計(jì)方案，JDK最早期的ThreadLocal就是這樣設(shè)計(jì)的。JDK1.3（不確定是否是1.3）之后ThreadLocal的設(shè)計(jì)換了一種方式。

我們先看看JDK8的ThreadLocal的get方法的源碼:

12345678910111213

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(); }

其中g(shù)etMap的源碼：

123	ThreadLocalMap getMap(Thread t) { return t.threadLocals;}

setInitialValue函數(shù)的源碼：

12345678910

private T setInitialValue() { T value = initialValue(); Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else createMap(t, value); return value;}

createMap函數(shù)的源碼：

123	void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue);}

簡單解析一下，get方法的流程是這樣的：

首先獲取當(dāng)前線程根據(jù)當(dāng)前線程獲取一個Map如果獲取的Map不為空，則在Map中以ThreadLocal的引用作為key來在Map中獲取對應(yīng)的value e，否則轉(zhuǎn)到5如果e不為null，則返回e.value，否則轉(zhuǎn)到5Map為空或者e為空，則通過initialValue函數(shù)獲取初始值value，然后用ThreadLocal的引用和value作為firstKey和firstValue創(chuàng)建一個新的Map

然后需要注意的是Thread類中包含一個成員變量：

1	ThreadLocal.ThreadLocalMap threadLocals = null;

所以，可以總結(jié)一下ThreadLocal的設(shè)計(jì)思路：每個Thread維護(hù)一個ThreadLocalMap映射表，這個映射表的key是ThreadLocal實(shí)例本身，value是真正需要存儲的Object。這個方案剛好與我們開始說的簡單的設(shè)計(jì)方案相反。查閱了一下資料，這樣設(shè)計(jì)的主要有以下幾點(diǎn)優(yōu)勢：

這樣設(shè)計(jì)之后每個Map的Entry數(shù)量變小了：之前是Thread的數(shù)量，現(xiàn)在是ThreadLocal的數(shù)量，能提高性能，據(jù)說性能的提升不是一點(diǎn)兩點(diǎn)(沒有親測)當(dāng)Thread銷毀之后對應(yīng)的ThreadLocalMap也就隨之銷毀了，能減少內(nèi)存使用量。

再深入一點(diǎn)

先交代一個事實(shí)：ThreadLocalMap是使用ThreadLocal的弱引用作為Key的：

12345678910111213141516171819202122

static class ThreadLocalMap { /** * 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. */ static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } } ... ...}

下圖是本文介紹到的一些對象之間的引用關(guān)系圖，實(shí)線表示強(qiáng)引用，虛線表示弱引用：

然后網(wǎng)上就傳言，ThreadLocal會引發(fā)內(nèi)存泄露，他們的理由是這樣的：

如上圖，ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal沒有外部強(qiáng)引用引用他，那么系統(tǒng)gc的時候，這個ThreadLocal勢必會被回收，這樣一來，ThreadLocalMap中就會出現(xiàn)key為null的Entry，就沒有辦法訪問這些key為null的Entry的value，如果當(dāng)前線程再遲遲不結(jié)束的話，這些key為null的Entry的value就會一直存在一條強(qiáng)引用鏈：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永遠(yuǎn)無法回收，造成內(nèi)存泄露。

我們來看看到底會不會出現(xiàn)這種情況。其實(shí)，在JDK的ThreadLocalMap的設(shè)計(jì)中已經(jīng)考慮到這種情況，也加上了一些防護(hù)措施，下面是ThreadLocalMap的getEntry方法的源碼：

12345678

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 return getEntryAfterMiss(key, i, e);}

getEntryAfterMiss函數(shù)的源碼：

12345678910111213141516

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; }

expungeStaleEntry函數(shù)的源碼：

1234567891011121314151617181920212223242526272829303132333435

private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // expunge entry at staleSlot tab[staleSlot].value = null; tab[staleSlot] = null; size--; // Rehash until we encounter 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) { 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; }

整理一下ThreadLocalMap的getEntry函數(shù)的流程：

首先從ThreadLocal的直接索引位置(通過ThreadLocal.threadLocalHashCode & (len-1)運(yùn)算得到)獲取Entry e，如果e不為null并且key相同則返回e；如果e為null或者key不一致則向下一個位置查詢，如果下一個位置的key和當(dāng)前需要查詢的key相等，則返回對應(yīng)的Entry，否則，如果key值為null，則擦除該位置的Entry，否則繼續(xù)向下一個位置查詢

在這個過程中遇到的key為null的Entry都會被擦除，那么Entry內(nèi)的value也就沒有強(qiáng)引用鏈，自然會被回收。仔細(xì)研究代碼可以發(fā)現(xiàn)，set操作也有類似的思想，將key為null的這些Entry都刪除，防止內(nèi)存泄露。但是光這樣還是不夠的，上面的設(shè)計(jì)思路依賴一個前提條件：要調(diào)用ThreadLocalMap的getEntry函數(shù)或者set函數(shù)。這當(dāng)然是不可能任何情況都成立的，所以很多情況下需要使用者手動調(diào)用ThreadLocal的remove函數(shù)，手動刪除不再需要的ThreadLocal，防止內(nèi)存泄露。所以JDK建議將ThreadLocal變量定義成private static的，這樣的話ThreadLocal的生命周期就更長，由于一直存在ThreadLocal的強(qiáng)引用，所以ThreadLocal也就不會被回收，也就能保證任何時候都能根據(jù)ThreadLocal的弱引用訪問到Entry的value值，然后remove它，防止內(nèi)存泄露。