1.ThreadLocal基本介绍
相信使用java语言做开发的同学,肯定多或多或少了解过ThreadLocal,简单来说就是一个“以当前Thread对象作为key的key-value存储结构,能实现多线程的读写安全”。那么他究竟是怎么实现的呢,它的实现源码并不是很长,下面直接从源码上来分析。
先看一个使用ThreadLocal存取数据的例子:
1.1 直接使用无参构造函数创建对象
//使用无参构造函数创建ThreadLocal实例,默认值为null
final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
//给子线程保存局部变量
threadLocal.set(100);
System.out.println("线程-" + Thread.currentThread().getId() + ",threadLocal.get() : " + threadLocal.get());
}
});
//给主线程保存局部变量
threadLocal.set(10);
thread1.start();
System.out.println("线程-" + Thread.currentThread().getId() + ",threadLocal.get() : " + threadLocal.get());
执行结果:
线程-1,threadLocal.get() : 10
线程-12,threadLocal.get() : 100
从执行结果中可以看出,两个线程存放变量值虽然都用同一个ThreadLocal变量,但不同线程能获取到正确的变量值的。
1.2 使用带初始值的方式创建对象
ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue() {
//默认的initialValue返回null,这里直接重写return我们需要的默认值
return 10;
}
};
System.out.println("threadLocal存储的默认值:" + threadLocal.get());
执行结果:
threadLocal存储的默认值:10
ThreadLocal的使用可以说是很简单了,下面开始分析,set()、get()方法内部的实现源码。
2.ThreadLocal源码分析
2.1 set()方法:
public void set(T value) {
Thread t = Thread.currentThread();
//先获取了当前的线程对象,传给getMap(),获取ThreaLocalMap对象,
//如果当前线程已经存在ThreadLocalMap对象,则直接存到已有的map中,否则走创建逻辑
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
- getMap(Thread):
ThreadLocalMap getMap(Thread t) {
//其实是获取了Thread对象的ThreadLocal.ThreadLocalMap对象
return t.threadLocals;
}
2.2 get()方法:
先把ThreadLocalMap放一放,再看看get()方法:
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
//和set()方法方式一样,也是从ThreadLocalMap中获取value
if (map != null) {
//ThreadLocalMap.getEntry()方法,传入的是当前ThreadLocal对象,获取ThreadLocalMap.Entry
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//如果调用过set()创建过跟Thread对象绑定的ThreadLocalMap对象,
//则走setInitialValue()方法取默认值
return setInitialValue();
}
- setInitialValue()
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;
}
2.3 ThreadLocalMap的数据结构
从上面的ThreadLocal的set和get方法可以看出,最后数据都存放到了ThreadLocalMap中。
- 取Value是getEntry(ThreadLocal<?> key)方法,
- 存Value是set(ThreadLocal<?> key, Object value)。
static class ThreadLocalMap {
//Entry将ThreadLocal对象作为弱引用的key,难道是考虑避免内存泄漏?
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
//初始容量为16
private static final int INITIAL_CAPACITY = 16;
//维护了一个Entry数组,这样就能按这样索引顺序获取value值:ThreadLocal->Entry->Value
private Entry[] table;
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//每一个ThreadLocalMap对象,都是创建新的Entry数组,就是一个thread对象对应一个
//threadlocalmap, 一个threadLocalMap对应一个Entry数组
table = new Entry[INITIAL_CAPACITY];
//private final int threadLocalHashCode = nextHashCode();
//采用hash值取一个尽量不重复的index,比使用循环遍历table数组高效
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
}
从上面的代码中可以看出ThreadLocalMap的存储结构如下:
下图为不同thread时的存储方式,一个thread对应一个threadLocalMap,也就对应一个Entry数组。
可见,不同的Thread时,用thread对象作为key,将值存档在不同的ThreadLocalMap中。
2.4 ThreadLocalMap.set()
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
//这个循环说明,如果当期i位置没有找到,就会逐个的取当前i的下一个位置判断是否已经存在,
//如果遍历完了table数组还是没有,则直接走循环外的,添加一个新的Entry元素的逻辑
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
//i位置已经存在Entry了,如果key值相等,则替换
if (k == key) {
e.value = value;
return;
}
//存在Entry,但是key为null,
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
- 可以看出该方法中,有判断key为null的情况,其实原因是ThreadLocalMap的key存放的是ThreadLocal的弱引用,如果仅存在ThreadLocalMap中对ThreadLocal对象的弱引用,那么进行GC后,最终这个key会为null,这样一来,就会存在key为null,value不为null的一些键值对。所以replaceStaleEntry就是移除这种元素。
2.5 ThreadLocalMap.getEntry() :
private Entry getEntry(ThreadLocal<?> key) {
//跟存放时同样的方式获取table的下标
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
//内部会清理掉对应value避免内存泄漏
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,说明对应的threadLocal对象已经被回收,需要清理掉对应value避免内存泄漏
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
如果简单的理解,其实ThreadLocalMap就是一个由数组实现的hash表,在获取Entry时能够通过先计算出hash值,然后直接通过table[hash]的方式获取value。
3.ThreadLocalMap存储的问题分析
3.1 同一个对象存放多个不同类型对象
怎么存储多个不用类型,比如我想在同一个Thread里存放10个不同类型的对象,那代码就会如下:
ThreadLocal<Integer> integerThreadLocal = new ThreadLocal<>();
threadLocal.set(10);
//存放double类型变量
ThreadLocal<Double> doubleThreadLocal = new ThreadLocal<>();
doubleThreadLocal.set(88.000);
//存放float类型变量
ThreadLocal<Double> FloatThreadLocal = new ThreadLocal<>();
doubleThreadLocal.set(88.000);
这种情况下,因为是同一个thread实例,所以ThreadLocalMap也会是同一个对象,也就是共用一个Entry数组,只是ThreadLocal对象不同,也就是ThreadLocalMap的key不同,所以会存放到table数组的不同位置。
同一个对象存放多个不同类型对象时结构如下:
这种情况下,对应关系就会如上所示,一个thread实例,一个threadLocalMap对象,然后根据不同的threadLocal对象,计算出不同的hash值,得出的数组下标不同,就会存放到同一个table数组的不同位置。当然这种情况也可直接将不同的类型对象组合为一个类就可以了。
3.2 内存泄漏问题
如前面2.4所说,在ThreadLocalMap中,作为key的ThreadLocal对象,是用弱引用的方式引用的,但是真正存放的value仍然是强引用,所以在ThreadLocalMap中会有对当key为null时,清理key为null的Entry元素。但是这些清理操作,都是需要触发set(),getEntry()的调用才会被执行,这样一来,如果key已经为null了,但是又没有在进行set()/get()存取操作,那么还是会存在value的内存泄漏问题,所以在使用ThreadLocal完毕后,最好使用remove()方法,清理掉对应ThreadLocalMap对象。