本文是对Java ThreadLocal（Java8）的源码的解析，对ThreadLocal基本使用还不了解的朋友可先快速学习ThreadLocal后再来阅读本文。
set方法
set方法可以让多个线程保存同一变量的副本。基本使用代码如下：
threadLocal.set(data);
那么为什么ThreadLocal可以起到线程隔离的作用呢？这就要进入set方法源码一探究竟了。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
//1
map.set(this, value);
else
//2
createMap(t, value);
}
代码很短，先获取当前的线程，也就是此时调用ThreadLocal的set方法的线程，然后获取ThreadLocalMap，ThreadLocalMap不空就设值，空就创建一个ThreadLocalMap。
ThreadLocalMap是ThreadLocal的静态内部类，从名字也可以看出来它是用于存储ThreadLocal的。跳进getMap方法可以看看。
//ThreadLocal.java
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//Thread.java
ThreadLocal.ThreadLocalMap threadLocals = null;
直接返回Thread的ThreadLocalMap，也就是说每个线程都自带一个ThreadLocalMap来存储不同的ThreadLocal。注意，在Java8以前ThreadLocalMap是ThreadLocal成员变量，Java8开始就变了。
线程创建时，它的ThreadLocalMap是空的。也就是说线程第一次调用set方法设值时，会运行代码2创建LocalThreadMap，下次再调用set才会运行代码1。先看看createMap方法做了什么。
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
代码很简单就是让当前调用set方法的线程new一个ThreadLocalMap。再看看它的构造方法做了什么。
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//1
table = new Entry[INITIAL_CAPACITY];
//2
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
//3
setThreshold(INITIAL_CAPACITY);
}
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
代码1的table是一个数组，用来保存Entry的，初始容量为16。初始容量的注释上解释道容量必须为2的n次方。接下来进行哈希运算决定新值在数组的插入位置，最后设置一个初始阈值。可以看的出来ThreadLocalMap并是直接用Java自带的HashMap，而是自己实现了Map的相关操作。
先看看代码1的Entry类，它是ThreadLocalMap的静态内部类。其实就是ThreadLocalMap存储的实体，以ThreadLocal为Key，set方法设置的值就是作为Value保存在Entry里的。Entry对ThreadLocal是弱引用，也就是说这个ThreadLocal在下一次Java GC时可能会被回收，采用弱引用的原因会在后面解释。
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
先分析一下稍微简单的代码3，它给map设置了一个初始阈值，当map元素个数超过阈值，map就需要扩容了，可以看到这里的阈值就是容量的2/3。
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
回到刚刚的代码2，代码二是用来决定Entry在table数组的插入位置的。
...
//2
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
...
//ThreadLocal.java
private final int threadLocalHashCode = nextHashCode();
插入位置就是ThreadLocal的哈希值和15（INITIAL_CAPACITY 为16）做与运算。threadLocalHashCode是一个常量，由nextHashCode方法得到，看看它的实现。
/**
* 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;
private static AtomicInteger nextHashCode = new AtomicInteger();
...
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
threadLocalHashCode是得到的值其实就是上一次nextHashCode的值加上0x61c88647的结果（因为用的是getAndAdd方法，先得值在自加0x61c88647），为了保证自加是原子操作，所以nextHashCode使用AtomicInteger而非int。HASH_INCREMENT为什么选用0x61c88647可参考这篇文章。
创建了ThreadLocalMap并把值存入，createMap方法就结束了。那么，下一次ThreadLocal再存值时，就运行文章最开始的代码1，回顾一下。
if (map != null)
//1
map.set(this, value);
跳进去看看。
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
//1
int i = key.threadLocalHashCode & (len-1);
//2
for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
//4
e.value = value;
return;
}
if (k == null) {
//5
replaceStaleEntry(key, value, i);
return;
}
}
//6
tab[i] = new Entry(key, value);
int sz = ++size;
//7
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
首先，先在代码1处求得待插入的位置，但这可能并不是最终位置，因为哈希表在插入时有可能出现碰撞的现象（就是说不同的值可能计算出来的插入地址相同），而代码2的for循环就是用来检测插入位置是否冲突的。这个for循环的工作流程是这样的。
如果插入位置是空着的，那没问题直接运行代码6插入就行了。如果插入位置被占用了，那就看看插入位置是否符合要求（代码），插入位置的ThreadLocal和现在调用set方法的ThreadLocal是同一个对象实例，说明本次的调用set方法是在更新副本变量值。
如果比较后发现插入位置的ThreadLocal和本ThreadLocal不是同一个对象实例，这个时候才是真正的碰撞。这里使用了线性检测法来处理冲突。简单的说就是发现插入位置i碰撞，就看看i+1位置是不是空着的，i+1也被占用了就再看看下一个位置行不行，终于找到空位了插入即可。for循环里的nextIndex方法就是在寻找下一个插入位置。如果i已经是数组的最后一个位置了，那就回到第0个位置继续检测。这么一来就总会找到一个空位了。
那么代码5是什么意思，字面上看就是取代旧的Entry。上面说过Entry是ThreadLocal的弱引用，进行一次GC后，Entry所引用的ThreadLocal可能会为空，Entry引用为空又占着table数组的一个空位，这个Entry里保存的副本值也就成了脏数据，此时调用replaceStaleEntry就是在重新利用这个Entry。
再重新读for循环的代码会发现，更新副本值（代码4）和重新利用已有的Entry（代码5）是不会消耗table数组空位的。可代码6新插入的Entry就不一样了，为了保证table数组的空位的到充分利用，每次新插入后都要清理一下脏的Entry及在必要时扩容，看看代码7的cleanSomeSlots方法。
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;
//1
i = expungeStaleEntry(i);
}
} while ( (n >>>= 1) != 0);
return removed;
}
刚刚提到过Entry引用的ThreadLocal可能会被回收，导致Entry携带脏数据，这个方法就是用来查找并回收这类Entry的。通过do-while循环查找，发现了Entry携带脏数据就调用代码1的expungeStaleEntry方法回收它。
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
...
}
把Entry的副本引用设为空，并将它从table数组里移除，接下来等垃圾回收器回收就行了。重新看看代码7的判断。
if (!cleanSomeSlots(i, sz) && sz >= threshold){
refresh();
}
cleanSomeSlots方法里如果找到了携带脏数据的Entry就会返回true，这么一来，只有在出现脏Entry且ThreadLocalMap容量只剩不到1/3时(threshold设定为总容量的2/3)才会调用refresh方法刷新,看看它做了什么。
private void rehash() {
//1
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
//2
if (size >= threshold - threshold / 4)
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);
}
}
现在代码1调用expungeStaleEntries方法做最后一次大回收，如果这次大回收后容量依然还是很低，那就只能调用resize方法扩容了。
expungeStaleEntries之所以叫大回收，是因为它直接把这个table数组遍历了一遍，这样就能最大范围地回收没用的Entry了。
get方法
ThreadLocal的get方法基本使用如下：
value = threadLocal.get();
看看源码
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
//1
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//2
return setInitialValue();
}
先获取当前线程，在获取这个线程的ThreadLocalMap，代码1获取到存储变量副本的Entry，不空就直接返回变量副本，空就调用代码2的setInitialValue方法设置初值。先来分析代码1的getEntry方法。
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//1
if (e != null && e.get() == key)
return e;
else
//2
return getEntryAfterMiss(key, i, e);
}
代码1先判断ThreadLocal是否匹配，上面讲过，可能出现ThreadLocal可能会被回收导致Entry返回空 又或者 碰撞监测导致插入位置后移，如果匹配就返回，不匹配就调用getEntryAfterMiss方法。
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)
//1
expungeStaleEntry(i);
else
//2
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
代码1是在重新利用没用的Entry，代码2是在寻找下一个合适的插入位置，上面讲过了。回到刚才getEntry方法，如果连ThreadLocalMap都为空，那么还得对ThreadLocalMap初始化，就是在setInitialValue方法中进行的。
...
//2
return setInitialValue();
}
private T setInitialValue() {
//1
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
protected T initialValue() {
return null;
}
代码1的获取副本的初始值，注意，如果不重写initialValue方法，返回值必然是空值。接下来对ThreadLocalMap初始化操作和刚刚讲解的set方法是一样的。如此一来ThreadLocal的get方法就解析完了。
remove方法
基本使用如下。
threadLocal.remove();
再看看源码。
//ThreadLocal.java
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
//ThreadLocalMap.java
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();
//1
expungeStaleEntry(i);
return;
}
}
}
寻找Entry的方法还是一样的，只是这回是将Entry回收(代码1)。
内存泄漏问题
上面讲到过Entry对ThreadLocal是弱引用，为什么要使用弱引用，而不使用强引用？可以先想想使用强引用会有怎样的后果。
ThreadLocalMap使用了线性检测法来判断处理碰撞。检测到i位置碰撞就看看i+1位置是否能用。问题就出现在这里。如果使用强引用除非手动把table数组的元素置空，否则GC是不会回收这个Entry的，即使Entry所引用的ThreadLocal及对应的变量副本确实没用了。ThreadLocal没用了又不能回收，table数组的元素越来越多，碰撞也越来越严重，如此恶性循环，能用的内存就越来越小了。
这回再想想用弱引用就能明白它的道理了。有一篇文章讨论过要不要使用ThreadLocal的remove方法。个人理解是这样的，ThreadLocalMap采用弱引用策略已经起到回收没用的Entry的作用，只是remove方法让程序更早地解除相关的引用关系，算是一种保障吧。
ThreadLocal 和 Thread私有成员变量 的区别
来看看下面这两个类。
class MyThread extends Thread{
private int mCount = 0;
public int getCount(){
return mCount;
}
public void increase(){
mCount++;
}
}
class MyThread2 extends Thread{
private ThreadLocal<Integer> mCount = new ThreadLocal();
public int getCount(){
return mCount.get();
}
public void increase(){
mCount.set(getCount());
}
}
这两个类对mCount操作的效果是一样的，但使用ThreadLocal和成员私有变量的出发点是不一样的。ThreadLocal是作用在不同的线程空间上的，而私有成员变量是作用在不同的对象实例上的。在MyThread2里 ，想要改变mCount只能在存储它的线程里修改。而在MyThread里，可以在不同的线程里改变同一线程的mCount。
参考文章
1.为什么使用0x61c88647
2.处理哈希冲突的线性探测法
3.使用ThreadLocal到底需不需要remove？
161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
