Java多线程基础 06.深入理解ThreadLocal
ThreadLocal的使用
ThreadLocal是一个存放线程本地变量的工具类。
ThreadLocal的线程本地性质
示例代码 1.1
public class ThreadLocalTest {
public static void main(String[] args) throws InterruptedException {
ThreadLocal<Integer> stringThreadLocal = new ThreadLocal<>();
new Thread(() -> {
stringThreadLocal.set(1);
while (true) {
}
}).start();
Thread.sleep(1000);
new Thread(() -> {
Integer integer = stringThreadLocal.get();
System.out.println(integer);
}).start();
}
}
输出:
null
ThreadLocal设置初始值
示例代码 1.2
public class ThreadLocalWithInitialTest {
public static void main(String[] args) throws InterruptedException {
ThreadLocal<Integer> stringThreadLocal = ThreadLocal.withInitial(() -> 99);
System.out.println(stringThreadLocal.get());
}
}
输出:
99
ThreadLocal的原理
Thread中有一个类型为ThreadLocal.ThreadLocalMap的threadLocals属性（见示例源码 2.1），先可以把它理解为key为ThreadLocal,value为Object的Map。
源码 2.1
public class Thread implements Runnable {
ThreadLocal.ThreadLocalMap threadLocals = null;
}
ThreadLocal.get方法
如源码2.2所示，当调用ThreadLocal实例的get方法时，会先获取从当前线程的threadLocals属性中获取。如果没找到，会进行初始化操作，最终返回设置的初始化值。
源码2.2 ThreadLocal代码片段
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;
}
}
//如果Thread.currentThread().threadLocals中找不到，则进行初始化。
return setInitialValue();
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
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;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocal.set方法
如源码2.3所示，当调用ThreadLocal实例的set方法时，会先判断当前线程的threadLocals是否已经初始化完成。如果threadLocals未初始化完成，会进行初始化；如果threadLocals已经初始化完成便会调用set方法将其写入threadLocals中。
源码2.3 ThreadLocal代码片段
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocal.remove方法
如源码2.4所示，ThreadLocal中的remove方法逻辑很简单，获取当前线程的threadLocals对象，并调用其remove方法。
源码2.4 ThreadLocal代码片段
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
}
ThreadLocalMap初始化
如源码 3.1.1所示，ThreadLocalMap初始化时，就将table初始化为长度16的数组，并基于初始长度计算出阈值threshold。
源码3.1.1 ThreadLocalMap代码片段
static class ThreadLocalMap {
private static final int INITIAL_CAPACITY = 16;
private Entry[] table;
private int size = 0;
private int threshold;
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);
}
/**
* 将阈值设置为 （当前数组长度 * 2）/ 3。
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
}
ThreadLocalMap.get方法
在讲ThreadLocalMap的get方法之前，需要先讲讲ThreadLocalMap中对哈希冲突的解决策略。
在散列表面对哈希冲突问题时通常有两种解决方案，链地址法和开地址法，除此之外还有再散列法和建立公共溢出区。链地址法就是将哈希表中每一个单元都设置为链表，Java中的HashMap就使用的链地址法。而ThreadLocalMap中使用的是开放地址法中的线性探测法，就是如果发现哈希冲突，就把元素放在下一个单元。
在了解ThreadLocalMap的哈希冲突解决策略之后，就可以很容易看懂get方法了，具体逻辑见源码3.2.1的注释。
源码3.2.1 ThreadLocalMap.getEntry
private Entry getEntry(ThreadLocal<?> key) {
// 计算在散列表中的索引
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
// 如果当前索引下不为空，同时e中的引用和key相同。
if (e != null && e.get() == key)
// 返回entry实例
return e;
// 有两种情况会走到else语句：
// 1：table[i]为空
// 2：table[i]不为空，但key不同，需要基于线性探测法进行查找。
else
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();
// 当前entry中的引用和key相同，返回entry。
if (k == key)
return e;
//判断当前slot中的entry#key关联的ThreadLocal对象是否已被GC回收了。
if (k == null)
//探测过期数据，回收slot。
expungeStaleEntry(i);
else
//更新index，继续向后搜索。
i = nextIndex(i, len);
//获取下一个slot中的entry。
e = tab[i];
}
return null;
}
private static int nextIndex(int i, int len) {
// 实现一个环形的访问
return ((i + 1 < len) ? i + 1 : 0);
}
ThreadLocalMap.expungeStaleEntry方法
源码3.3.1 ThreadLocalMap.expungeStaleEntry方法
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 清空当前过期slot，方便gc。
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
Entry e;
int i;
// rehash直到遇到null
for (i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//如果当前slot里面内容过期了，再做一次清空
if (k == null) {
e.value = null;
tab[i] = null;
size--;
} else {
//没有过期，会进else语句
int h = k.threadLocalHashCode & (len - 1);
//如果当前元素因为hash冲突，所以进行一次rehash。
if (h != i) {
//清空当前slot
tab[i] = null;
//再基于线性探测法查找slot，存在entry。
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
ThreadLocalMap.remove方法
如源码 3.4.1所示，ThreadLocalMap中的remove方法会基于线性探测法，依次循环。如果找到对应entry，便清空entry中引用，并触发一次过期数据探测。
expungeStaleEntry方法流程见上。
源码3.4.1 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;
}
}
}
ThreadLocalMap.set方法
源码3.5.1 ThreadLocalMap中set相关代码
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 计算哈希表中的节点槽位
int i = key.threadLocalHashCode & (len-1);
//这个for循环，就是对开地址法的实现。
//如果当前槽位不为空,就会一直往后找空位。
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//如果发现Entry已存在，那就直接替换Entry中的value。
if (k == key) {
e.value = value;
return;
}
// 如果发现过期的slot
if (k == null) {
//替换过期数据的逻辑。
replaceStaleEntry(key, value, i);
return;
}
}
//什么时候会执行到这边？
//直到循环到空slot，仍然没有找到对应的entry，同时也未出现过期entry
//往空位中设置Entry。
tab[i] = new Entry(key, value);
int sz = ++size;
//做一次启发式清理
//条件一：!cleanSomeSlots(i, sz) 成立，说明启发式清理工作 未清理到任何数据..
//条件二：sz >= threshold 成立，说明当前table内的entry已经达到扩容阈值了..会触发rehash操作。
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
private void rehash() {
//这个方法执行完后，当前散列表内的所有过期的数据，都会被清理。
expungeStaleEntries();
//清理完过期数据后，如果当前散列表内的entry数量仍然达到了 threshold * 3/4，触发扩容。
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);
}
}
ThreadLocalMap.replaceStaleEntry方法
当ThreadLocalMap.set方法中，线性探测到过期entry，便会进入当前方法。
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
//表示 开始探测式清理过期数据的 开始下标。默认从当前 staleSlot开始。
int slotToExpunge = staleSlot;
//向前探测过期数据，找到空节点之后最前面的过期数据。
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len)){
if (e.get() == null){
slotToExpunge = i;
}
}
//从staleSlot往后去查找，直到null为止。
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == key) {
//向后查询的过程中，找到了对应的entry。
//进行替换操作
e.value = value;
//进行交换操作
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
//条件成立：
// 1.向前检查过期数据过程中未发现过期的entry。
// 2.向后检查过期数据过程中也未发现过期的entry
if (slotToExpunge == staleSlot)
//开始探测式清理过期数据的下标 修改为 当前循环的index。
slotToExpunge = i;
//cleanSomeSlots ：启发式清理
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
//条件1：k == null 成立，说明当前遍历的entry是一个过期数据..
//条件2：slotToExpunge == staleSlot 成立，一开始时 的向前查找过期数据 并未找到过期的entry.
if (k == null && slotToExpunge == staleSlot)
//因为向后查询过程中查找到一个过期数据了，更新slotToExpunge 为 当前位置。
//前提条件是 前驱扫描时 未发现 过期数据..
slotToExpunge = i;
}
//什么时候执行到这里呢？
//向后查找过程中 并未发现 k == key 的entry
//直接将新数据添加到 table[staleSlot] 对应的slot中。
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
//条件成立：除了当前staleSlot 以外 ，还发现其它的过期slot了.. 所以要开启 清理数据的逻辑..
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
ThreadLocalMap.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];
//条件一：e != null 成立
//条件二：e.get() == null 成立，说明当前slot中保存的entry 是一个过期的数据..
if (e != null && e.get() == null) {
//重新更新n为 table数组长度
n = len;
/表示清理过数据.
removed = true;
//以当前过期的slot为开始节点 做一次 探测式清理工作
i = expungeStaleEntry(i);
}
// 假设table长度为16
// 16 >>> 1 ==> 8
// 8 >>> 1 ==> 4
// 4 >>> 1 ==> 2
// 2 >>> 1 ==> 1
// 1 >>> 1 ==> 0
} while ( (n >>>= 1) != 0);
return removed;
}
ThreadLocalMap.resize方法
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
//计算出扩容后的新表大小
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
//表示新table中的entry数量。
int count = 0;
for (int j = 0; j < oldLen; ++j) {
Entry e = oldTab[j];
if (e != null) {
ThreadLocal<?> k = e.get();
if (k == null) {
//清除当前Entry，帮助GC回收。
e.value = null;
} else {
//当前Entry是非过期数据，需要迁移到扩容后的新表。
//计算出当前entry在扩容后的新表的 存储位置。
int h = k.threadLocalHashCode & (newLen - 1);
//while循环 就是拿到一个距离h最近的一个可以使用的slot。
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
