EZLippi-浮生志

Java ThreadLocal原理分析

大家或多或少听说过ThreadLocal这个词,我们创建的对象默认是所有线程可以访问的,多线程并发修改对象时就会可能出现数据不一致的问题,使用ThreadLocal创建的对象只能被当前线程访问,每个线程保存一个对象的副本,在多线程操作时是线程安全的。

ThreadLocal用法简介

比如有这样一个类:

1
2
3
4
5
6
7
public class Counter{
private int count;
public Counter(int cnt) {
this.count = cnt;
}
//省略setter()和getter()方法
}

我们希望多线程访问Counter对象时,各个线程各自保留一份count计数,那可以这么写:

1
2
3
ThreadLocal<Counter> threadLocal = new ThreadLocal<>();
threadLocal.set(new Counter(0));
Counter counter = threadLocal.get();

如果你不想每次调用的时候都去初始化,那可以重写ThreadLocal的initValue()方法给ThreadLocal设置一个对象的初始值,如下所示:

1
2
3
4
5
6
ThreadLocal<Counter> threadLocal = new ThreadLocal<Counter>() {
@Override
protected Counter initialValue() {
return new Counter(0);
}
};

这样每次调用threadLocal.get()的时候,会去判断当前线程是否存在Counter对象,如果不存在则调用initValue()方法初始化。

ThreadLocal实现原理

我们先来看一下ThreadLocal的get()方法,如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
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();
}

调用get()方法时先获取到当前线程,然后通过线程获取每个线程绑定的ThreadLocalMap对象,map中的key就是ThreadLocal对象,Value就是实际我们要访问的对象,上面的例子中是Counter对象,如果Entry为空,那就调用setInitialValue()方法设置初始值。

ThreadLocalMap实现原理

从前面可以看出每个线程内部有个ThreadLocalMap,从java.lang.Thread类的源码也可以看到Thread类有个ThreadLocal.ThreadLocalMap threadLocals属性,接下来我们来分析下它的实现原理:
ThreadLocalMap和WeakHashMap实现有点类似,也是利用了WeakReference来和GC建立关联,因为ThreadLocal对象被线程对象引用,如果一个线程的生命周期比较长,那可能会出现内存泄露的问题,ThreadLocalMap借助弱引用巧妙的解决了这个问题,源码如下所示:

1
2
3
4
5
6
7
8
9
10
11
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
//这里的Entry并不是一个链表,如果出现hash碰撞,会放到数组的下一个位置
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
}

从源码可以看到ThreadLocalMap的Entry继承自WeakReference,Entry中的key是一个弱引用,也就是说线程类持有了ThreadLocal对象的一个弱引用,当ThreadLocal对象没有其他强引用关联时,在GC时会把ThreadLocal对象回收掉,但是这里仅仅回收ThreadLocal对象,Entry对象和Value并没有回收,ThreadLocalMap里就可能存在很多Key为null的Entry,所以需要在调用map.getEntry()时对key为null的对象进行处理,源码如下:

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
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
//当前位置没有找到,可能Hash碰撞了
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)
//检测到有个ThreadLocal对象被回收了,这个时候去清理后面所有Key为null的Entry
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}

从源码中可以看到ThreadLocalMap清理掉key为Null的Entry的时机是根据ThreadLocal对象的hashCode去获取entry时发生了hash碰撞,并且下一个entry的key为null时才去清理,因为ThreadLocalMap的Entry和普通Map的不太一样,一般的Map是一个链表数组,而它的数组每个元素就是一个Entry,如果出现Hash碰撞了就放到数组的下一个位置,因此如果get的时候发现没有碰撞可以认为当前Map中的元素还不多,一旦检测到碰撞了并且下一个entry的key被回收了,就调用expungeStaleEntry()来释放ThreadLocal为null的那些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
28
29
30
31
32
33
34
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) {
//清理key为null的entry
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
//hashCode发生了变化,重新放置entry
if (h != i) {
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}

总结

ThreadLocal可以保证每个线程拥有一个变量的副本,实现了线程隔离,主要利用了每个Thread有个ThreadLocalMap,ThreadLocalMap保存了该线程拥有的所有ThreadLocal对象,并利用弱引用机制避免了Map无线增大导致内存泄露的问题。

🐶 您的支持将鼓励我继续创作 🐶