JDK源码之ThreadLocal 类分析
一 概述
ThreadLocal类提供了线程局部 (thread-local) 变量。这些变量与普通变量不同，每个线程都可以通过其 get 或 set方法来访问自己的独立初始化的变量副本
ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联，类里面定义了一个map,key为ThreadLocal，value为值，存储每一个线程的变量
Thread类里面引用了这个内部类的map实例，从而达到线程隔离
二 源码分析
属性
// 获取下一个hashCode值
private final int threadLocalHashCode = nextHashCode();
// 获取下一个hashCode,ThreadLocal 中使用了斐波那契散列法，来保证哈希表的离散度
private static int nextHashCode() {
// 每一次获取值时，加上HASH_INCREMENT为下一次获取的值
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 开始为0，每次创建ThreadLocal实例，值都会累加
private static AtomicInteger nextHashCode = new AtomicInteger();
// 加数值: 0x61c88647 = 2^32 * 黄金分割比(0.618),
// 斐波那契数列： 当n趋向于无穷大时，前一项与后一项的比值越来越逼近黄金比,即0.618
private static final int HASH_INCREMENT = 0x61c88647;
//提供给子类初始化值使用
protected T initialValue() {
return null;
}
核心方法
// 通过Supplier函数初始化变量值，使用子类构造器进行初始化
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
return new ThreadLocal.SuppliedThreadLocal<>(supplier);
}
// ThreadLocal扩展子类，接收一个Supplier函数进行值初始化
static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {
private final Supplier<? extends T> supplier;
SuppliedThreadLocal(Supplier<? extends T> supplier) {
this.supplier = Objects.requireNonNull(supplier);
}
// 覆写父类方法
@Override
protected T initialValue() {
return supplier.get();
}
}
public ThreadLocal() {}
// 返回当前线程的变量副本值
public T get() {
Thread t = Thread.currentThread();
// 获取线程实例引用的ThreadLocalMap
ThreadLocal.ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocal.ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
// 值为空，重新初始化
return setInitialValue();
}
ThreadLocal.ThreadLocalMap getMap(Thread t) { return t.threadLocals; }
private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocal.ThreadLocalMap map = getMap(t);
// 赋值
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);
}
// 设置ThreadLocal的值，还是设置的thread实例引用的map
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocal.ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//清除值，key是ThreadLocal，所以直接使用this
public void remove() {
ThreadLocal.ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
// 调用map的remove方法
m.remove(this);
}
// Thread 类里面创建线程时候初始化init方法调用的，主要是复制参数中的table构建一个新map返回
static ThreadLocal.ThreadLocalMap createInheritedMap(ThreadLocal.ThreadLocalMap parentMap) {
return new ThreadLocal.ThreadLocalMap(parentMap);
}
// 只允许子类调用此方法，ThreadLocal调用直接抛异常
T childValue(T parentValue) { throw new UnsupportedOperationException(); }
三 静态内部类ThreadLocalMap
ThreadLocal中的静态内部类ThreadLocalMap，这个类本质上是一个map，和HashMap之类的实现相似，依然是key-value的形式，其中有一个内部类Entry，其中key可以看做是ThreadLocal实例，
在ThreadLocal中并没有对于ThreadLocalMap的引用，ThreadLocalMap的引用在Thread类中
每个线程在向ThreadLocal里塞值的时候，其实都是向自己所持有的ThreadLocalMap里塞入数据；
读的时候同理，首先从自己线程中取出自己持有的ThreadLocalMap，然后再根据ThreadLocal引用作为key取出value，
基于以上描述，ThreadLocal实现了变量的线程隔离
Entry
/**
* Entry继承WeakReference，(弱引用：当一个对象仅仅被weak reference指向, 而没有任何其他strong reference指向的时候, 如果GC运行, 那么这个对象就会被回收)
* 并且用ThreadLocal作为key.如果key为null
* (entry.get() == null)表示key不再被引用，表示ThreadLocal对象被回收
* 因此这时候entry也可以从table从清除。
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 初始容量
private static final int INITIAL_CAPACITY = 16;
// 存放数据的数组
private Entry[] table;
// 数组里面entrys的个数，可以用于判断table当前使用量是否超过负因子
private int size = 0;
// 进行扩容的阈值，表使用量大于它的时候进行扩容
private int threshold; // Default to 0
// 设置阈值为参数的三分之二
private void setThreshold(int len) { threshold = len * 2 / 3;}
核心方法
/**
* ThreadLocalMap使用线性探测法来解决哈希冲突，线性探测法的地址增量di = 1, 2, ... , m-1，其中，i为探测次数。
* 该方法一次探测下一个地址，直到有空的地址后插入，若整个空间都找不到空余的地址，则产生溢出。
* 假设当前table长度为16，也就是说如果计算出来key的hash值为14，如果table[14]上已经有值，并且其key与当前key不一致，那么就发生了hash冲突，
* 这个时候将14加1得到15，取table[15]进行判断，这个时候如果还是冲突会继续下一个，如果是最后的则重新回到0，取table[0],以此类推，直到可以插入。
* 可以把table看成一个环形数组
*/
// 获取环形数组的下一个索引
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
// 获取环形数组的上一个索引
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
// 构造器初始化
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化table
table = new Entry[INITIAL_CAPACITY];
// 计算索引， & (INITIAL_CAPACITY - 1),这是取模的一种方式，对于2的幂作为模数取模，用此代替%(2^n)，目的是均匀分布在数组中
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 设置值
table[i] = new Entry(firstKey, firstValue);
size = 1;
// 设置阈值
setThreshold(INITIAL_CAPACITY);
}
/**
* 构建一个包含所有parentMap中Inheritable ThreadLocals的ThreadLocalMap返回
* 该函数只被 createInheritedMap() 调用.即只在Thread类的init方法里面调用（init方法调用了createInheritedMap（））,目的是将父线程的变量值复制到当前线程中
*/
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
// 逐一复制 parentMap 的记录到当前线程中
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
//此处获取的都是InheritableThreadLocal类，ThreadLocal的子类，用于父线程变量传递的类
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
// 如果是ThreadLocal，就会抛异常
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
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
// e不为空，但是key不相等时候再找
return getEntryAfterMiss(key, i, e);
}
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)
// 如果key为null，则清除掉无效的entry
expungeStaleEntry(i);
else
// 环形向后扫描
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
/**
* 根据获取到的索引进行循环，如果当前索引上的table[i]不为空，在没有return的情况下，
* 就使用nextIndex()获取下一个地址，即线性探测法。
*/
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
// key相同则更新value，set成功
e.value = value;
return;
}
/**
* table[i]上的key为空，说明被回收了
* 这个时候说明改table[i]可以重新使用，用新的key-value将其替换,并删除其他无效的entry
*/
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
/**
* 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;
}
}
}
//key-value替换 staleSlot位置的值
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
/**
* 根据传入的无效entry的位置（staleSlot）,向前扫描，当前已经是无效的，可能前面也有无效的，找到最开始无效的一个进行替换，维护线性探测法
* 一段连续的entry(这里的连续是指一段相邻的entry并且table[i] != null),
* 直到找到一个无效entry，或者扫描完也没找到
*/
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
/**
* 向后扫描一段连续的entry
*/
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
/**
* 如果找到了key，直接替换，也就是与table[staleSlot]进行替换，此时staleSlot位置已经替换了对应key的值
*/
if (k == key) {
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
//如果向前查找没有找到无效entry，则更新slotToExpunge为当前值i
if (slotToExpunge == staleSlot)
slotToExpunge = i;
// 此时，staleSlot位置已经设置值了，应该从 slotToExpunge 位置开始往后清除
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
/**
* 如果向前查找没有找到无效entry，并且当前向后扫描的entry无效，则更新slotToExpunge为当前值i
*/
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
/**
* 如果没有找到key,也就是说key之前不存在table中
* 就直接最开始的无效entry——tab[staleSlot]上直接新增即可
*/
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
/**
* slotToExpunge != staleSlot,说明存在其他的无效entry需要进行清理。
*/
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
/**
* 连续段清除
* 根据传入的staleSlot,清理对应的无效entry——table[staleSlot],
* 并且根据当前传入的staleSlot,向后扫描一段连续的entry(这里的连续是指一段相邻的entry并且table[i] != null),
* 对可能存在hash冲突的entry进行rehash，并且清理遇到的无效entry.
* @param staleSlot key为null,需要无效entry所在的table中的索引
* @return 返回下一个为空的solt的索引。
*/
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
Entry e;
int i;
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// key为null，直接清理
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
/**
* 计算出来的索引h，与其现在所在位置的索引——i不一致，置空当前的table[i]
* 从h开始向后线性探测到第一个空的slot，把当前的entry挪过去。
*/
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
/**
* 启发式的扫描清除，扫描次数由传入的参数n决定
* @param i 从i向后开始扫描（不包括i，因为索引为i的Slot肯定为null）
* @param n 控制扫描次数，正常情况下为 log2(n) ，
* 如果找到了无效entry，会将n重置为table的长度len,进行段清除。
* map.set()点用的时候传入的是元素个数，replaceStaleEntry()调用的时候传入的是table的长度len
*/
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;
i = expungeStaleEntry(i);
}
//无符号的右移动，可以用于控制扫描次数在log2(n)
} while ( (n >>>= 1) != 0);
return removed;
}
private void rehash() {
expungeStaleEntries();
/**
* threshold = 2/3 * len
* 所以threshold - threshold / 4 = 1en/2
* 这里主要是因为上面做了一次全清理所以size减小，需要进行判断。
* 判断的时候把阈值调低了。
*/
if (size >= threshold - threshold / 4)
resize();
}
/**
* 扩容，扩大为原来的2倍（这样保证了长度为2的冥）
*/
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;
}
// 清空全部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);
}
}
