Java 并发 ---ThreadLocal源码分析

ThreadLocal是什么

Java中的ThreadLocal类允许我们创建只能被同一个线程读写的变量。因此，如果一段代码含有一个ThreadLocal变量的引用，即使两个线程同时执行这段代码，它们也无法访问到对方的ThreadLocal变量

如何创建ThreadLocal

ThreadLocal是一个类，那么可以直接new出来，并且可以指定其类型

ThreadLocal<Integer>id=new ThreadLocal<Integer>();

ThreadLocal 常用方法

1、设置值

id.set(1);

2、读取保存在ThreadLocal变量中的值：

Integer value = id.get();

3、从ThreadLocal中移除某个变量

id.remove();

ThreadLocal使用方法很简单，ThreadLocal就是一个变量，可以给这个变量赋值（set），取值（get），删除值（remove），只是这个变量和线程相关，同一段ThreadLocal代码在不同线程里面是不一样的，数据相互独立。

ThreadLocal 源码浅析

分析源码，个人还是喜欢先大概看一下定义，然后再从方法中进行切入（注意看方法注释）。

get 方法

/**
* Returns the value in the current thread's copy of this
* thread-local variable.  If the variable has no value for the
* current thread, it is first initialized to the value returned
* by an invocation of the {@link #initialValue} method.
*
* @return the current thread's value of this thread-local
*/
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();
}

来梳理一下逻辑：

（1）获得当前线程

（2）获得ThreadLocalMap

来看看ThreadLocalMap是什么

static class ThreadLocalMap

是ThreadLocal的静态内部类，大致看一下，似乎还很复杂，在ThreadLocalMap的下还有一个静态内部类

static class Entry extends WeakReference<ThreadLocal<?>>

不过从名字我们可以看出来 ThreadLocalMap 应该是一个key-value的结构，那我们就来找找key和value是什么

/**
* 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 = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}

这是ThreadLocalMap 的一个构造函数，从形参我们可以知道，key就是ThreadLocal，至于value暂时可以不用care,不过可以猜测是我们set时的value。

/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;

/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;

/**
* The number of entries in the table.
*/
private int size = 0;

table是一个Entry的数组而table的大小是2的倍数，初始大小为16.到这里又要中断去看一下Entry是什么

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

Entry是ThreadLocalMap的一个静态内部类，继承了弱引用，key作为了WeakReference的引用，value是Entry的value,于WeakReference，在下一次GC的时候，会回收WeakReference关联的对象（如果该关联的对象不再被使用）

ThreadLocalMap的结构大致明白了，ThreadLocalMap确实是key-value结构，而这个结构是通过Entry来实现的，key是ThreadLocal 实例，value到这里还不确定（其实看一下set就很容易看出这个就是我们传入的value）。

回到ThreadLocalMap的构造函数

（1）生成一个Entry （key-value）数组 叫table

（2）通过名称和下一行代码，我们知道 这是通过一个hashcode生成一个索引

（3）然后将key ，value 封装成一个 Entry实例，table[i]指向这个实例。

知道ThreadLocalMap，我们再回到get中，再来看看getMap

ThreadLocalMap map = getMap(t);

/**
* Get the map associated with a ThreadLocal. Overridden in
* InheritableThreadLocal.
*
* @param  t the current thread
* @return the map
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}

我们看到返回的是一个线程中的threadLocals，我们到线程中一探究竟

/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

这个threadLocals就是我们开始分析的ThreadLocalMap，到这里我们大致知道了:thread中有一个ThreadLocalMap 它是一个key-value结构，key是我们定义的ThreadLocal，value就是我们设置的值，继续往下看：

if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}

通过 thread中的ThreadLocalMap获取一个Entry ,参数是this,是谁在调用get方法？是通过我们定义的ThreadLocal变量调用，那么这个this就是我们的ThreadLocal。前面我们知道ThreadLocal就是key,那么现在传入的就是key，那么肯定就是为了获取value

/**
* 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.
*
* @param  key the thread local object
* @return the entry associated with key, or null if no such
*/
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);
}

getEntry中 通过key计算一个索引，然后根据table查出Entry，如果查出的Entry的key是我们传入的key，那么返回这个Entry。（else 先不看），再对照上面取得Entry中的value，返回，结束。

因为我们是一步一步分析的，到这里是不是有点混乱，那我们来梳理一下：

（1）Thread 里面有一个 ThreadLocalMap, ThreadLocalMap中一个Entry数据结构，它是一个key-value结构，key是ThreadLocal,value是我们需要存的值。由Entry构成了一个table数组，用于存放这些Entry，通过ThreadLocal去存取值，实际就是把自己做为key,把值放到thread中的ThreadLocalMap中，这样就能明白为什么这些数据是线程相关的了，应该这些数据就是存到线程里面，别的线程里面肯定没有呀，画了个图，方便大家理解：

set 方法

有了上面的基础，再来看set就好理解了

/**
* Sets the current thread's copy of this thread-local variable
* to the specified value.  Most subclasses will have no need to
* override this method, relying solely on the {@link #initialValue}
* method to set the values of thread-locals.
*
* @param value the value to be stored in the current thread's copy of
*        this thread-local.
*/
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

（1）首先获取线程里面的ThreadLocalMap

（2）如果map 为空，那么先创建,creat里面就是我们前面分析过的ThreadLocalMap的构造函数，就不再分析了。

（3）如果map不为空，那么就设置值，key就是当前的ThreadLocal(this)

/**
* 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.

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) {
e.value = value;
return;
}

if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

（1）根据key 计算得到一个索引值

（2）根据索引值可以得到table 中的Entry

（3）按照指定的条件遍历table，nextIndex从字面意思可以看出是计算下一个索引值（这就是所谓的指定的条件），刚开始table[i]肯定是null的，所以暂时不看那段for循环

（4）将key，value 封装成Entry,将table[i]指向Entry。

ok,set方法我们也大致了解了，基本对ThreadLocal有了比较清楚的认识了，至少是揭开了它神秘的面纱。

ThreadLocal 源码深入分析

前面我们大致看了一下set 和 get 方法，了解了ThreadLocal的原理，但是还有一些比较细节的地方还没有仔细琢磨，在前面我们看到在get或者set的时候，都会通过key来计算一下索引（table的下标），在回想一下，table是一个数组，存取数据是通过下标来进行的，而这个下标是通过key来计算得到，这个很明显就是一种hash的计算，当然通过名称（key.threadLocalHashCode）我们也很容易的猜到是这样的,在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.
*/
private final int threadLocalHashCode = nextHashCode();

/**
* The next hash code to be given out. Updated atomically. Starts at
* zero.
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();

/**
* The difference between successively generated hash codes - turns
* implicit sequential thread-local IDs into near-optimally spread
* multiplicative hash values for power-of-two-sized tables.
*/
private static final int HASH_INCREMENT = 0x61c88647;

/**
* Returns the next hash code.
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}

可以看到一个静态的原子变量nextHashCode ，在nextHashCode()方法，不断的增加这个原子变量的计数，而这个增量就是HASH_INCREMENT，从此我们可以知道，每当实例一个ThreadLocal，那么其threadLocalHashCode 都在其原来的值上不断增加 HASH_INCREMENT。

在get 方法中的getEntry：

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

在计算索引的时候 用到了ThreadLocal实例的threadLocalHashCode ，然后和(table.length-1)相与，那么得到一个在0-table.length-1的数，这个数就用来存数据，所有取数据的时候直接用相同的方法得到索引就可以了。

当然知道hash的都肯定知道hash碰撞这个词，如果在索引i对应的位置已经存过值了，那么就该重新计算另一个位置索引（这个后面再细谈）

如果在计算的索引中不存在指定的ThreadLocal，那么说明可能发生了碰撞，也可能没有个ThreadLocal,那么执行getEntryAfterMiss 方法

/**
* Version of getEntry method for use when key is not found in
* its direct hash slot.
*
* @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)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}

如果取出的ThreadLocal不为空，但是不是我们指定的ThreadLocal，那么说明发生了碰撞，需要找下一个索引（再hash）

/**
* Increment i modulo len.
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}

再次hash的方法也很简单，也就是线性递增，依次往后找就可以了，那么说明存数据的时候也是这种方法（很显然嘛，存取数据的hash算法一定要一致）

如果取出的k（ThreadLocal）为空(这里Entry 不为空),那么说明Entry 关联的这个key(ThreadLocal)被回收了（在程序中我们也许不在引用某个ThreadLocal实例，那么后面可能就会被gc回收掉 ），这个时候需要清理hash表（table），执行 expungeStaleEntry

/**
* 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
*
* @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 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;
}

（1）将table中的索引位置的数据清楚掉

（2）重新hash，为什么要重新hash，因为虽然索引i这个位置的数据没有了，但是在i位置上发生了hash碰撞的Entry数据是通过i再次hash计算得到下一个位置的值，既然i的位置数据都没有了，那么那些Entry有什么意义呢（同时table length的大小变化了，所以必须重新hash），所以需要为它们重新计算需要存放的位置。

所以才有了后面的循环，获得不断获得下个索引值，如果该位置关联的ThreadLocal为空，那么清除数据，否则根据当前的length和 ThreadLocal 重新计算存储的位置，如果重新计算出的位置有数据，那么再hash,依次进行，知道找到位置可以放为止。

最后 ，回到get 方法，如果table中get不到值，那么就会执行：

return setInitialValue();

这里面很简单 就是设置一个初始值，而这个值通过：

protected T initialValue() {
return null;
}

这个方法得到，因此我们可以重写该方法，设置我们自己需要的初始值。

看完get方法 ，我们再来回顾一下ThreadLocalmap里面的set 方法：

/**
* 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.

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) {
e.value = value;
return;
}

if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

再开始，我们没有分析循环，因为第一次放入值，肯定不会执行循环。当通过计算出来的索引值获取Entry 不为空时，那么就执行循环

（1）如果取出的Entry就是我们要的数据，那么很好，结束

（2）如果取出的Entry 的key（ThreadLocal）为空，这就麻烦了，说明该Entry关联的ThreadLocal 被回收了，又需要整理table 了，来看看replaceStaleEntry

/**
* 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.
*
* 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.)
*
* @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;
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
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.
if (k == key) {
e.value = value;

tab[i] = tab[staleSlot];
tab[staleSlot] = e;

// Start expunge at preceding stale entry if it exists
if (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 slot
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);

// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

说一下主要逻辑吧，想一下，当前这个Entry的key为空了，那么其前一个Entry 的key 是不是也可能为空了呢（这里的前一个并不是i-1的那个，而是基于hash算法得出的前一个，这个很简单，如果由i算i+1的那么就逆推就好了），当然可能

（1）从此Entry往前找失效的Entry，如果找到了就用slotToExpunge标记

（2）从此Entry（取名 a）开始往后找,如果找到了一个key 和我们当前需要设置数据的key相同，那么说明有这个Entry（取名b），我们直接重新改它的值就好（e.value = value;），因为我们在找需要的key是，发现a的key为空，那么我们就把b和a交换，那么b的查找路径就会变短，接下来我们就需要整理 Entry 中key为空的节点了，如果前面有key为空的那么就从前面开始，否则从当前位置开始，expungeStaleEntry 前面讲过，里面主要就是搬数据（重新hash）,cleanSomeSlots 里面比较简单，就是清理Entry,里面调用了expungeStaleEntry。

（3）如果在前面的查找并整理table中没有找到 我们要设置数据的 ThreadLocal,那么就需要构造一个新的Entry了

remove 方法

之所以把remove 放到这里讲，其实remove就是清理table,这个恰好在前面就分析过了

public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}

/**
* Remove the entry for key.
*/
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;
}
}
}

简单贴一下源码就可以了，过程就不再分析了.

ok 分析完了，完了。