-
并发编程之ThreadLocal
并发编程之ThreadLocal
前言
当多线程访问共享可变数据时,涉及到线程间同步的问题,并不是所有时候,都要用到共享数据,所以就需要线程封闭出场了。
数据都被封闭在各自的线程之中,就不需要同步,这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭。
本文主要介绍线程封闭中的其中一种体现:ThreadLocal,将会介绍什么是 ThreadLocal;从 ThreadLocal 源码角度分析,最后介绍 ThreadLocal 的应用场景。
什么是ThreadLocal
ThreadLocal 是 Java 里一种特殊变量,它是一个线程级别变量,每个线程都有一个 ThreadLocal 就是每个线程都拥有了自己独立的一个变量,竞态条件被彻底消除了,在并发模式下是绝对安全的变量。
可以通过 ThreadLocal
会自动在每一个线程上创建一个 T 的副本,副本之间彼此独立,互不影响,可以用 ThreadLocal 存储一些参数,以便在线程中多个方法中使用,用以代替方法传参的做法。
下面通过例子来了解下 ThreadLocal:
@Slf4j
public class ThreadLocalUtil {
/**
* static 确保全局只有一个保存 String 对象的 ThreadLocal 实例
* final 确保 ThreadLocal 实例不可更改 防止被意外改变 导致存入的值和取出的值不一致,并且还能防止 ThreadLocal 实例内存泄漏
*/
private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();
public static void main(String[] args) throws InterruptedException {
// 主线程设置值
THREAD_LOCAL.set("主线程值");
String v = THREAD_LOCAL.get();
log.info("线程pool-1-thread-1执行之前," + Thread.currentThread().getName() + " 线程获取到的值为:{}", v);
ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService.submit(() -> {
String s = THREAD_LOCAL.get();
log.info(Thread.currentThread().getName() + " 线程获取到的值为:{}", s);
// 子线程设置值
THREAD_LOCAL.set("子线程值");
s = THREAD_LOCAL.get();
log.info("重新设置值之后," + Thread.currentThread().getName() + " 线程获取到的值为:{}", s);
log.info(Thread.currentThread().getName() + "线 程执行结束");
THREAD_LOCAL.remove();
});
// 等待子线程执行结束
Thread.sleep(1000L);
v = THREAD_LOCAL.get();
log.info("线程pool-1-thread-1执行之后," + Thread.currentThread().getName() + " 线程获取到的值为:{}", v);
THREAD_LOCAL.remove();
}
}
首先通过 static final 定义了一个 THREAD_LOCAL 变量,其中 static 是为了确保全局只有一个保存 String 对象的 ThreadLocal 实例;
final 确保 ThreadLocal 的实例不可更改,防止被意外改变,导致放入的值和取出来的不一致,另外还能防止 ThreadLocal 的内存泄漏。上面的例子是演示在不同的线程中获取它会得到不同的结果,运行结果如下:
14:33:42.176 [main] INFO com.linkcld.redis.util.ThreadLocalUtil - 线程pool-1-thread-1执行之前,main 线程获取到的值为:主线程值
14:33:42.307 [pool-1-thread-1] INFO com.linkcld.redis.util.ThreadLocalUtil - pool-1-thread-1 线程获取到的值为:null
14:33:42.307 [pool-1-thread-1] INFO com.linkcld.redis.util.ThreadLocalUtil - 重新设置值之后,pool-1-thread-1 线程获取到的值为:子线程值
14:33:42.307 [pool-1-thread-1] INFO com.linkcld.redis.util.ThreadLocalUtil - pool-1-thread-1线 程执行结束
14:33:43.307 [main] INFO com.linkcld.redis.util.ThreadLocalUtil - 线程pool-1-thread-1执行之后,main 线程获取到的值为:主线程值
首先在 pool-1-thread-1 线程执行之前,先给 THREAD_LOCAL 设置为 主线程值,然后可以取到这个值,然后通过创建一个新的线程以后去取这个值,发现新线程取到的为 null,意外着这个变量在不同线程中取到的值是不同的,不同线程之间对于 ThreadLocal 会有对应的副本,接着在线程 pool-1-thread-1 中执行对 THREAD_LOCAL 的修改,将值改为 子线程值,可以发现线程 pool-1-thread-1 获取的值变为了 子线程值,主线程依然会读取到属于它的副本数据 主线程值,这就是线程的封闭。
看到这里,我相信大家一定会好奇 ThreadLocal 是如何做到多个线程对同一对象 set 操作,但是 get 获取的值还都是每个线程 set 的值呢,接下来就让我们进入源码解析环节:
ThreadLocal 源码解析
首先看下 ThreadLocal 都有哪些重要属性:
// 当前 ThreadLocal 的 hashCode 由 nextHashCode 计算得来的,用于计算当前 ThreadLocal 再 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 哈希魔数,主要与斐波那契散列法和黄金分割相关
private static final int HASH_INCREMENT = 0x61c88647;
// 返回计算出的hash值,其值为 i * HASH_INCREMENT,其中 i 代表调用次数
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 保证了一台机器上,每个 ThreadLocal 的 threadLocalHashCode 值是唯一的
rivate static AtomicInteger nextHashCode = new AtomicInteger();
其中的 HASH_INCREMENT 也不是随便取的,它转化为十进制是 1640531527,2654435769 转换成 int 类型就是 -1640531527,2654435769 等于 (√5-1)/2 乘以 2 的 32 次方。(√5-1)/2 就是黄金分割数,近似为 0.618,也就是说 0x61c88647 理解为一个黄金分割数乘以 2 的 32 次方,它可以保证 nextHashCode 生成的哈希值,均匀的分布在 2 的幂次方上,且小于 2 的 32 次方。
下面用例子来证明下:
@Slf4j
public class ThreadLocalUtil2 {
private static final int HASH_INCREMENT = 0x61c88647;
public static void main(String[] args) {
int n = 5;
int max = 2 << (n - 1);
for (int i = 0; i < max; i++) {
System.out.print(i * HASH_INCREMENT & (max - 1));
System.out.print(" ");
}
}
}
运行结果为:
0 7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25
可以发现元素索引值完美的散列在数组当中,并没有出现冲突。
ThreadLocalMap
除了上述属性外,还有一个重要的属性 ThreadLocalMap,ThreadLocalMap 是 ThreadLocal 的静态内部类,当一个线程有多个 ThreadLocal 时,需要一个容器来管理多个 ThreadLocal,ThreadLocalMap 的作用就是管理线程中多个 ThreadLocal,源码如下:
static class ThreadLocalMap {
// 键值对的存储结构
static class Entry extends WeakReference<ThreadLocal<?>> {
// ThreadLocal 对应的value值
Object value;
Entry(ThreadLocal<?> k, Object v) {
// ThreadLocal 是弱引用的,当GC时会被回收掉,但是 value 不会被回收
super(k);
value = v;
}
}
// 默认初始容量 16 必须是2的幂
private static final int INITIAL_CAPACITY = 16;
// 底层时 Entry 数组,根据需要进行扩容,数组的大小必须是 2 的幂
private Entry[] table;
// 数组的大小
private int size = 0;
// 数组的扩容阈值 默认是 0
private int threshold;
// 数组扩容阈值为 长度的 2/3
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
}
从源码中看到 ThreadLocalMap 其实就是一个简单的 Map 结构,底层是数组,有初始化大小,也有扩容阈值大小,数组的元素是 Entry,Entry 的 key 就是 ThreadLocal 的引用,value 是 ThreadLocal 的值。ThreadLocalMap 解决 hash 冲突的方式采用的是线性探测法,如果发生冲突会继续寻找下一个空的位置。
这样的就有可能会发生内存泄漏的问题,下面让我们进行分析:
ThreadLocal 内存泄漏
ThreadLocal 在没有外部强引用时,发生 GC 时会被回收,那么 ThreadLocalMap 中保存的 key 值就变成了 null,而 Entry 又被 threadLocalMap 对象引用,threadLocalMap 对象又被 Thread 对象所引用,那么当 Thread 一直不终结的话,value 对象就会一直存在于内存中,也就导致了内存泄漏,直至 Thread 被销毁后,才会被回收。
那么如何避免内存泄漏呢?
在使用完 ThreadLocal 变量后,需要我们手动 remove 掉,防止 ThreadLocalMap 中 Entry 一直保持对 value 的强引用,导致 value 不能被回收,其中 remove 源码如下所示:
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
remove 方法的时序图如下所示:
remove 方法是先获取到当前线程的 ThreadLocalMap,并且调用了它的 remove 方法,从 map 中清理当前 ThreadLocal 对象关联的键值对,这样 value 就可以被 GC 回收了。
那么 ThreadLocal 是如何实现线程隔离的呢?
ThreadLocal 的 set 方法
我们先去看下 ThreadLocal 的 set 方法,源码如下:
// set 方法
public void set(T value) {
// 获取当前thread信息
Thread t = Thread.currentThread();
// 获取当前线程所在的 ThreadLocalMap
ThreadLocalMap map = getMap(t);
// map 不为空直接set值
if (map != null)
map.set(this, value);
else
// map 为空时,需要先创建 map
createMap(t, value);
}
// 创建map,并保存值
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
set 方法的作用是把我们想要存储的 value 给保存进去。set 方法的流程主要是:
- 先获取到当前线程的引用
- 利用这个引用来获取到 ThreadLocalMap
- 如果 map 为空,则去创建一个 ThreadLocalMap
- 如果 map 不为空,就利用 ThreadLocalMap 的 set 方法将 value 添加到 map 中
set 方法的时序图如下所示:
其中 map 就是我们上面讲到的 ThreadLocalMap,可以看到它是通过当前线程对象获取到的 ThreadLocalMap,接下来我们看 getMap方法的源代码:
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
getMap 方法的作用主要是获取当前线程内的 ThreadLocalMap 对象,原来这个 ThreadLocalMap 是线程的一个属性,下面让我们看看 Thread 中的相关代码:
// ThreadLocalMap 是线程的一个属性,所以可以保证在多线程环境下的线程安全
ThreadLocal.ThreadLocalMap threadLocals = null;
可以看出每个线程都有 ThreadLocalMap 对象,被命名为 threadLocals,默认为 null,所以每个线程的 ThreadLocals 都是隔离独享的。
调用 ThreadLocalMap.set() 时,会把当前 threadLocal 对象作为 key,想要保存的对象作为 value,存入 map。
其中 ThreadLocalMap.set() 的源码如下:
// ThreadLocalMap set 方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
// 计算 key 在数组中的下标
int i = key.threadLocalHashCode & (len-1);
// 遍历数组,找到 threadLocal 对象
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
// 获取下标位置处的 ThreadLocal 对象
ThreadLocal<?> k = e.get();
// 键值 ThreadLocal 匹配成功的话,直接更新 map 对于下标的 value 值
if (k == key) {
e.value = value;
return;
}
// 如果 key 不存在的话,说明 ThreadLocal 被GC清理了,直接替换掉
if (k == null) {
// 替换 Entry 方法
replaceStaleEntry(key, value, i);
return;
}
}
// 直接遇到了空槽也没有匹配到ThreadLocal对象,那么在此空槽处保存ThreadLocal对象和value值
tab[i] = new Entry(key, value);
// 数组长度+1
int sz = ++size;
// 如果没有卡槽需要清理并且数组长度 大于等于 数组长度的 2/3,数组需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
// 扩容的过程就是对所有的 key 进行重新哈希的过程
rehash();
}
// 判断是否有卡槽需要清理的方法
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);
}
} while ( (n >>>= 1) != 0);
return removed;
}
相信到这里,大家应该对 Thread、ThreadLocal 以及 ThreadLocalMap 的关系有了进一步的理解,下图为三者之间的关系:
ThreadLocal 的 get 方法
了解完 set 方法后,让我们看下 get 方法,源码如下:
// ThreadLocal get 方法
public T get() {
// 获取当前线程
Thread t = Thread.currentThread();
// 获取ThreadLocalMap 方法
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;
}
}
// 如果 map 为空的话,需要初始化 map
return setInitialValue();
}
// 初始化 map 方法,返回的值 null
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;
}
get 方法的主要流程为:
- 先获取到当前线程的引用
- 获取当前线程内部的 ThreadLocalMap
- 如果 map 存在,则获取当前 ThreadLocal 对应的 value 值
- 如果 map 不存在或者找不到 value 值,则调用 setInitialValue() 进行初始化
get 方法的时序图如下所示:
其中每个 Thread 的 ThreadLocalMap 以 threadLocal 作为 key,保存自己线程的 value 副本,也就是保存在每个线程中,并没有保存在 ThreadLocal 对象中。
其中 ThreadLocalMap.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);
}
ThreadLocalMap 的 resize 方法
当 ThreadLocalMap 中的 ThreadLocal 的个数超过容量阈值时,ThreadLocalMap 就要开始扩容了,我们一起来看下 resize 的源代码:
// 当需要扩容的时候,需要重新哈希
private void rehash() {
// 清除需要清理的卡槽
expungeStaleEntries();
// 使用较低的阈值进行加倍以避免磁滞。2/3 * size * 3/4 = 1/2 * size
if (size >= threshold - threshold / 4)
// 扩容
resize();
}
// 扩容算法,数组容量 * 2
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();
// 如果有需要清理的ThreadLocal,把value置空,方便GC回收
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;
}
resize 方法主要是进行扩容,同时会将垃圾值标记方便 GC 回收,扩容后数组大小是原来数组的两倍。
ThreadLocal 应用场景
ThreadLocal 的特性也导致了应用场景比较广泛,主要的应用场景如下:
- 线程间数据隔离,各线程的 ThreadLocal 互不影响
- 方便同一个线程使用某一对象,避免不必要的参数传递
- 全链路追踪中的 traceId 或者流程引擎中上下文的传递一般采用 ThreadLocal
- Spring 事务管理器采用了 ThreadLocal
- Spring MVC 的 RequestContextHolder 的实现使用了 ThreadLocal