我的jdk源码（七）：ThreadLocal类
一、概述
ThreadLocal类是一个本地线程副本变量工具类。主要用于将私有线程和该线程存放的副本对象做一个映射，各个线程之间的变量互不干扰，在高并发场景下，可以实现无状态的调用，特别适用于各个线程依赖不通的变量值完成操作的场景。 简单说ThreadLocal就是一种以" 空间换时间 "的做法，在每个Thread里面维护了一个以开地址法实现的ThreadLocal.ThreadLocalMap，把数据进行隔离，数据不共享，从而保证线程安全。 下面就来深入分析一下ThreadLocal类的源码。
二、源码解析
(1) 成员变量，源码如下：
//ThreadLocal对象的hashcode
private final int threadLocalHashCode = nextHashCode();
//即将分配的下一个ThreadLocal实例的threadLocalHashCode的值
private static AtomicInteger nextHashCode =
new AtomicInteger();
//连续生成的哈希码之间的差异——将隐式顺序线程本地id转换为接近最优扩散的乘法哈希值，用于大小为2的幂的表。
private static final int HASH_INCREMENT = 0x61c88647;HASH_INCREMENT这个值是一个非常有意思的数值，由斐波那契散列演算而来，是菲波那切数，也叫黄金分割数，通过理论与实践，当我们用0x61c88647作为魔数累加为每个ThreadLocal分配各自的ID也就是threadLocalHashCode再与2的幂取模，能均匀的产生哈希码的分布，以此大大减少ThreadLocalMap的哈希冲突。
至于AtomicInteger()我们会在后面讲解AtomicInteger类的源码的时候学习到。
(2) nextHashCode()方法，源码如下：
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}nextHashCode()方法，就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的threadLocalHashCode，然后nextHashCode的值增加HASH_INCREMENT这个值。
(3) set()方法，源码如下：
public void set(T value) {
//获取当前线程
Thread t = Thread.currentThread();
//获取当前的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
//如果ThreadLocalMap存在，则调用ThreadLocalMap的set方法进行设置值
map.set(this, value);
else
//如果不存在，则调用ThreadLocal的createMap方法
createMap(t, value);
}(4) 那么我们先进入到ThreadLocal类中的静态内部类 ThreadLocalMap中的set()方法，观察插入值的过程，源码如下：
private void set(ThreadLocal key, Object value) {
//Entry是ThreadLocalMap的静态内部类，是一个WeakReference弱引用
Entry[] tab = table;
int len = tab.length;
//根据当前传入的key获取桶的坐标
int i = key.threadLocalHashCode & (len-1);
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal k = e.get();
//判断i坐标下，存的key是否与传入进来ThreadLocal的一致，一致则修改value值
if (k == key) {
e.value = value;
return;
}
//不一致，表示作为Entry的key的ThreadLocal已经被GC回收，则调用replaceStaleEntry()方法
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
//如果没有清理到数据，并且sz >= threshold，则执行rehash()方法。threshold=len * 2/3。
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}最关键的就是replaceStaleEntry()方法，我们进入源码看看：
private void replaceStaleEntry(ThreadLocal key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
//先将slotToExpunge的值设置为staleSlot，然后向前遍历
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
//如果找到e!=null，但是却已经被gc回收，则更新slotToExpunge的值为当前坐标，目的是为了标记最前面位置的e.get()=null的元素位置
if (e.get() == null)
slotToExpunge = i;
//然后再由staleSlot位置向后遍历，目的是为了查找是否有当前要存的这个元素
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal k = e.get();
//如果先找到了key相等的Entry，则直接更新，并且更换已存在的k所在的元素位置和staleSlot位置，也就是将刚更新的元素往前移，并且将k=null的位置清空
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
//更新完value后，判断slotToExpunge值是否与staleSlot值想等，也就是判断在更新的元素前面，是否还存在Entry.get()=null的元素，如果有，则执行cleanSomeSlots()方法进行清理
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
//如果找到了为空的元素，并且slotToExpunge 与staleSlot值相同，则修改slotToExpunge值为当前Entry所在的位置值i
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
//最后，如果slotToExpunge 值与staleSlot值不同，也就是存在被gc回收了的元素，则调用cleanSomeSlots()方法进行清除
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}总结一下，ThreadLocal在调用set()方法时，分为以下4种情况：
1.通过hash计算后的槽位对应的Entry数据为空，这里直接将数据放到该槽位即可。
2.槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值一致，这里直接更新该槽位的数据。
3.槽位数据不为空，往后遍历过程中，在找到Entry为null的槽位之前，没有遇到key过期的Entry，遍历散列数组，线性往后查找，如果找到Entry为null的槽位，则将数据放入该槽位中，或者往后遍历过程中，遇到了key值相等的数据，直接更新即可。
4.槽位数据不为空，往后遍历过程中，在找到Entry为null的槽位之前，遇到key过期的Entry，往后遍历过程中，一到了index=7的槽位数据Entry的key=null，散列数组下标为7位置对应的Entry数据key为null，表明此数据key值已经被垃圾回收掉了，此时就会执行replaceStaleEntry()方法，该方法含义是替换过期数据的逻辑，以index=7位起点开始遍历，进行探测式数据清理工作。详细可拆分为以下3步：
a. 以当前节点(index=7)向前迭代，检测是否有过期的Entry数据，如果有则更新slotToExpunge值。碰到null则结束探测。
b.从当前节点staleSlot向后查找key值相等的Entry元素，找到后更新Entry的值并交换staleSlot元素的位置(staleSlot位置为过期元素)，更新Entry数据，然后开始进行过期Entry的清理工作。
c. 向后遍历过程中，如果没有找到相同key值的Entry数据，创建新的Entry，替换table[stableSlot]位置，然后开始进行过期Entry的清理工作。
再看一下set()方法的最后，实际上是扩容机制。当set操作最后，没有清理任何元素，并且当前的size已经大于等于threshold（len * 2/3）时，则调用rehash()方法，源码如下：
private void rehash() {
//这里首先是会进行探测式清理工作，从table的起始位置往后清理
expungeStaleEntries();
//清理完毕之后，桶内只剩下完整的元素，不再存在ThreadLocal弱引用被GC回收的元素，再判断完整元素的数量是否已经达到了3/4，这里就和HashMap的负载因子一致了。
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);
}
}
//探测式清理方法具体实现
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;
}
//扩容方法
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
//扩容后容量变为原来的2倍
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 {
//重新计算老元素们的hash值，重新分配桶，如果出现hash冲突则往后寻找最近的entry为null的槽位，遍历完成之后，oldTab中所有的entry数据都已经放入到新的tab中了。
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
//计算新的扩容阈值，threshold = len * 2 / 3;取2/3是因为存在一些脏数据，也就是ThreadLocal弱引用被GC回收了的元素
setThreshold(newLen);
size = count;
table = newTab;
}ThreadLocalMap作为ThreadLocal的静态内部类，有它的独特之处：
1. Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。
2. ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用。
3. 每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了数据隔离。
4. ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表或者数组+红黑树，而ThreadLocalMap只有数组。
5. ThreadLocalMap存放的元素Entry， 它的key是ThreadLocal k ，继承自WeakReference， 也就是我们常说的弱引用类型。
讲到弱引用类型，我们再顺便说一下java中的4中引用类型：
1. 强引用：我们常常new出来的对象就是强引用类型，只要强引用存在，垃圾回收器将永远不会回收被引用的对象，哪怕内存不足的时候。
2. 使用SoftReference修饰的对象被称为软引用，软引用指向的对象在内存要溢出的时候被回收。
3. 使用WeakReference修饰的对象被称为弱引用，只要发生垃圾回收，若这个对象只被弱引用指向，那么就会被回收。
4. 虚引用是最弱的引用，在 Java 中使用 PhantomReference 进行定义。虚引用中唯一的作用就是用队列接收对象即将死亡的通知。
(5) 既然已经进入到了ThreadLocalMap中，我们就接着看看ThreadLocalMap中的getEntry()方法，源码如下：
private Entry getEntry(ThreadLocal key) {
//先用与运算计算得到桶的位置i
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//如果e元素不是空，也没被回收，并且ThreadLocal对象也相同，则直接返回e
if (e != null && e.get() == key)
return e;
//如不相同，则执行getEntryAfterMiss()方法
else
return getEntryAfterMiss(key, i, e);
}
private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
//如果e不为空，则分为以下几种情况
while (e != null) {
ThreadLocal k = e.get();
//k相等，表示找到了Entry对象，直接返回
if (k == key)
return e;
//k=null，表示此位置的Entry的ThreadLocal弱引用已经被gc回收，调用expungeStaleEntry()方法进行清理
if (k == null)
expungeStaleEntry(i);
//如果key不为空，则继续向后遍历
else
i = nextIndex(i, len);
//直至找到最后，都没合适的，则返回空
e = tab[i];
}
return null;
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}(6) 我们再看看ThreadLocalMap中的remove()方法，源码如下：
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;
}
}
}remove方法和get方法类似，也是找出对应的Entry对象，然后调用其clean方法清理。
(7) ThreadLocalMap的重要方法就分析到这里，我们回到ThreadLocal中来，看看ThreadLocal的get()方法，源码如下：
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();
}
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;
}
protected T initialValue() {
return null;
}根据源码可看到，ThreadLocal的get()方法先去获取当前线程的ThreadLocalMap中的Entry对象，如果不为空直接返回Entry的value值，如果为空，则调用initialValue方法，这个方法可以被重写 ，默认返回为null，将当前线程的ThreadLocal对象保存在ThreadLocalMap中，返回上层null。setInitialValue()方法中的处理逻辑细节与ThreadLocal的set()方法中大致相同，原理可翻看上文。
(8) ThreadLocal的remove()方法，源码如下：
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}可以看出，ThreadLocal的remove()方法实则是调用了ThreadLocalMap的remove()方法，具体逻辑查看上文。
三、总结
ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享。 下一篇我们将进入到java.util包中学习集合类的源码，敬请期待《我的jdk源码（八）：AbstractList List家族的骨架实现类》。
更多精彩内容，敬请扫描下方二维码，关注我的微信公众号【Java觉浅】，获取第一时间更新哦！
