ThreadLocal原理分析

概述

​ 在解决多线程共享变量是,我们常常使用synchronzed或者锁限制共享变量同一时刻只能有一个线程修改,这是通过互斥解决的变量的安全性,而ThreadLocal是jdk提供的一种通过为每个线程复制一个副本的方式来保证共享变量的并发安全。用算法中常用的两个概念来描述,前者是通过以时间换取空间的方式实现,而后者是通过以空间换取时间的方式实现(每个线程都有个变量的副本,线程建修改访问共享变量互不影响)。这篇文章,我们将对ThreadLocal的原理和使用进行深入的学习。

ThreadLocal使用示例

​ 下面,我们先通过一个简单的示例了解下ThreadLocal如何使用,具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class SeqRunnable implements Runnable {
private ThreadLocal<Integer> threadLocalSeq;

public SeqRunnable(ThreadLocal<Integer> threadLocalSeq) {
this.threadLocalSeq = threadLocalSeq;
}

@Override
public void run() {
if (threadLocalSeq.get() == null) {
threadLocalSeq.set(0);
}
for (int i = 0; i < 5; i++) {
threadLocalSeq.set(threadLocalSeq.get() + i);
System.out.println("thread name = " + Thread.currentThread().getName() + ", seqNum =" + threadLocalSeq.get());
}
}
}

//测试类
public class ThreadLocalTest {

private ThreadLocal<Integer> seqNum = new ThreadLocal<>();

public static void main(String []args) {
ThreadLocalTest threadLocalTest = new ThreadLocalTest();
Thread thread1 = new Thread(new SeqRunnable(threadLocalTest.seqNum), "thread1");
Thread thread2 = new Thread(new SeqRunnable(threadLocalTest.seqNum), "thread2");
thread1.start();
thread2.start();
}
}

​ 输出结果:

1
2
3
4
5
6
7
8
9
10
thread name = thread2, seqNum =0
thread name = thread2, seqNum =1
thread name = thread1, seqNum =0
thread name = thread2, seqNum =3
thread name = thread1, seqNum =1
thread name = thread2, seqNum =6
thread name = thread1, seqNum =3
thread name = thread2, seqNum =10
thread name = thread1, seqNum =6
thread name = thread1, seqNum =10

​ 上述代码通过可以看出thread1和thead2中对变量seqNum的改变互不影响,类似于thread1和thead2中分别持有变量seqNum的一个副本,然后分别在副本上操作。

​ 了解了上面的使用示例,如果让我们去实现一个上面ThreadLocal,我们会如何实现?

​ 最容易的实现方式是在ThreadLocal类中持有一个map,map的可以key是线程id,value是该线程对应的变量的副本,这样就实现了上述每个线程中持有一个变量副本的功能。但是,这种实现方式会存在一种问题。如果线程结束了map中该threadLocal的副本可能仍然存在,并且无法清理。因为副本变量并没有被线程持有,线程也就没有清理该副本的权利。

​ 另一种实现方式,副本变量被线程的某个内部成员变量持有,ThreadLocal可以通过访问当前线程设置和获取这个副本变量。线程只有副本变量,可以在任何时候去清理这个变量。

ThreadLocal源码分析

​ JDK中ThreadLocal是通过我们上面提到的第二种方式来实现的,在Thread类中有一个如下的ThreadLocalMap,可以暂时将这个变量看作为一个map(后面我们会详细分析这个类),key是threadLocal,value就是对应的变量副本。

1
ThreadLocal.ThreadLocalMap threadLocals = null;

​ ThreadLocal通过get操作获取值,通过set操作设置值,下面我们看下这个两个关键的函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//get操作
public T get() {
//1.获取当前线程t
Thread t = Thread.currentThread();
//2.获取线程的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
if (map != null) {
//3.获取线程的map中threadLocal为key的value
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//4.如果没有相关的值进行初始化
return setInitialValue();
}

//set操作
public void set(T value) {
//1.获取当前线程t
Thread t = Thread.currentThread();
//2.获取线程的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
//3.设置map中以threadLocal为key的元素值
if (map != null)
map.set(this, value);
else
createMap(t, value);
}

​ 可以看出,以上代码逻辑非常的简单,主要的逻辑都在ThreadLocalMap,因此想搞清楚ThreadLocal的实现必须了解ThreadLocalMap。在对ThreadLocalMap进行介绍前,我们再看下ThreadLocal的对象的hashcode的实现。具体如下代码:

1
2
3
4
5
6
7
8
9
10
//threadLocal的hashcode,可以看出hashcode是0x61c88647倍数,保证项目中  						 
private final int threadLocalHashCode = nextHashCode();

private static AtomicInteger nextHashCode = new AtomicInteger();
//这是个神奇的数字,可以使得在使其均匀的分布在2的N次方数组中,具体可以了解斐波那契散列法
private static final int HASH_INCREMENT = 0x61c88647;

private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}

​ 0x61c88647 这个值可以通过2^32 * 黄金分割比大致算出,而斐波那契数列有个性质,在n无限大的时候,前一项和后一项的比例就是黄金分割比。

ThreadLocalMap源码分析

​ ThreadLocalMap是ThreadLocal的静态内部类,实现了类似hashmap的功能,用来存储线程的副本变量。我们知道HashMap中通过拉链法解决hash冲突,在ThreadLocalMap中使用的使用的是开发定址法解决hash冲突,在这种方法中,如果第i个位置发生了冲突,那么就会检测第(i+1)个位置。具体我们通过下面的图示了解开发定址方法冲突解决方案:

​ 为什么ThreadLocalMap要使用开放定址法进行冲突解决,猜测是因为ThreadLocal中使用斐波那契散列法是的冲突的可能性比较小,并且ThreadLocalMap内部数据量不会很大。

​ 接下来我们具体看下ThreadLocalMap的内部实现,首先我们看下它的成员变量:

1
2
3
4
5
6
7
8
//初始默认大小,和hashmap类似,同样为16
private static final int INITIAL_CAPACITY = 16;
//table数组,存储具体key-value
private Entry[] table;
//数据大小
private int size = 0;
//扩容阈值,在ThreadLocalMap中该值等于2/3 * size,及ThreadLocalMap的装载因子为2/3
private int threshold; // Default to 0

​ 我们再看下ThreadLocalMap中的实体Entry的是如何定义:

1
2
3
4
5
6
7
8
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}

​ 结构很简单,只有key和value成员,但是这个定义却是ThreadLocalMap核心,将key定义为一个指向ThreadLocal的弱引用,这样可以在一定程度上减小内存泄漏的发生。试想这样一种场景,ThreadLocalMap中存在一个key为threadLocal1的键值对,当我们在程序中将threadLocal1置为空,这个时候如果Entry中key是强引用,那么即使threadLocal1已经没用引用,也不会回收。因为在ThreadLocalMap中的某个entry中持有这个对象的引用。这样,就造成了内存泄漏,直到持有ThreadLocalMap的线程结束生命周期。弱引用的使用,可以在一定程度下减少这种情况发生,因为使用弱引用,如果threadLocal1被置为null,那么在下一次gc回收是threadLocal1就会被回收掉。

为什么说Entry引入弱引用只能在一定程度上减少内存泄漏的发生?因为即使entry的key被回收了,那么value还是没有回收。为了解决这个剩余的问题,ThreadLocalMap在查询,插入,扩容等操作内都会进行脏entry(key为null,及key指向的entry已经被回收)的清理工作。下面我们从get操作开始分析:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
private Entry getEntry(ThreadLocal<?> key) {
//找到key在table中的下标
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
//存在即返回entry
if (e != null && e.get() == key)
return e;
else
//不存在(分为的确不存在e==null或者该位置发生冲突导致真实元素在后面),向后寻找直到entry为null,因为使用的是开发定址冲突解决方案
return getEntryAfterMiss(key, i, e);
}

//从i到table.length - 1位置寻找匹配的key-value
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
//循环向后查询直到遇到一个entry为null结束
while (e != null) {
ThreadLocal<?> k = e.get();
//找到匹配的entry
if (k == key)
return e;
//顺便进行脏entry的清理工作,entry!=null&&key=null证明该entry为脏entry
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}

​ 我们继续看下set操作,主要过程就是计算key所在的下标,如果没有冲突直接插入元素,否则会通过开放定址的方式向后一个位置继续探查是否冲突,在这个过程中会顺便进行脏entry的清除。在元素插入的最后会判断是否需要扩容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
private void set(ThreadLocal<?> key, Object value) {
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)]) {
ThreadLocal<?> k = e.get();
//如果位置i没有冲突直接插入元素
if (k == key) {
e.value = value;
return;
}
//有重复顺便进行脏数据的清理,replaceStaleEntry会用后面的entry(如果存在)代替脏entry
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}

tab[i] = new Entry(key, value);
int sz = ++size;
//在没有脏entry可以清理并且达到扩容阈值进行扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

​ 扩容操作与hashmap类似,将size增大为原来的二倍,通过new一个新table数据,遍历元素设置到新的数组中最后用新数组替换老数组,完成扩容。

​ 最后我们看下删除元素操作,也是比较简单,找到key在table中对应的entry,将entry的key置为null(设置为脏entry),然后利用expungeStaleEntry进行脏entry清理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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) {
//将key置为null
e.clear();
//进行脏entry的清理
expungeStaleEntry(i);
return;
}
}
}

​ 从上面的get,set,remove方法中我们可以看到ThreadLocalMap无时无刻不在为清理脏entry做工作,expungeStaleEntry,cleanSomeSlots以及replaceStaleEntry都是进行脏entry清理写的逻辑。想深入了解这几个函数可以查看https://www.jianshu.com/p/dde92ec37bd1

参考

https://www.jianshu.com/p/dde92ec37bd1

https://juejin.im/post/5cced289f265da03804380f2

袁琼琼 wechat
欢迎您扫一扫上面的微信公众号,订阅我的博客!
多谢支持,共同成长!
0%