基本
定义
- ThreadLocal,即线程变量是一个以
ThreadLocal对象为键,任意对象为值的存储结构
。这个结构会被附带在线程上,也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值- 通过set(T)方法来设置一个值,在当前线程下再通过get()方法获取到原先设置的值
图解
源码
nextHashCode
- 是ThreadLocal 的唯一ID
private final int threadLocalHashCode = nextHashCode();
- CAS方法:nextHashCode
// static变量,和nextHashCode方法配合产生唯一ID
private static AtomicInteger nextHashCode =
new AtomicInteger();
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// AtomicInteger
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
ThreadLocalMap
1. ThreadLocalMap里的getMap方法
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
- Thread中的ThreadLocalMap
ThreadLocal.ThreadLocalMap threadLocals = null;
- ThreadLocalMap的数据结构
在ThreadLocal中定义,Thread依赖
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
....
private Entry[] table;
}
}
Entry
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
- ThreadLocal作为弱引用封装到Entry里(作为WeakReference里的T)
- 即Entry里封装的是 key-value
set方法
- set源码
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
- createMap : ThreadLocalMap的构造函数
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
// 通过Hash值确定索引
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
// private static final int INITIAL_CAPACITY = 16;
setThreshold(INITIAL_CAPACITY);
}
// 超过长度的2/3时需要扩容
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
- ThreadLocalMap的set方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);
// 若Hash冲突,则会用nextIndex方法,(地址+1)
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;
return;
}
// k是被回收的弱引用
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
// 清除key已经为null的Entry,之后size还是大于threshold,则重构
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
get方法
- 源码
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;
}
}
// 如果map还没定义,则new一个map,并返回null
return setInitialValue();
}
- map.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);
}
关于弱引用和内存泄漏
弱引用
每个thread中都存在一个map,map的类型是ThreadLocal.ThreadLocalMap,先看下图
- Map中的key作为一个threadLocal实例,这个Map使用了弱引用,当把threadlocal实例置为null后,没有任何强引用指向threadlocal实例(堆内存中的实例),所以此时该实例可以被顺利GC
- 若此时每个key都强引用指向threadlocal,那么这个threadlocal就会因为和entry存在强引用无法被回收,造成内存泄漏,除非线程结束,线程被回收,map也跟着回收,否则将无法被回收
内存泄漏
- 虽然上述弱引用解决了key的内存泄漏问题,及threadlocal可以被及时回收,但是value却依然存在内存泄露的问题
- map里的value跟实际的堆内存地址存在着强引用(因为只有这一个引用,所以只能用强引用),此时存在从current thread连过来的强引用,即此时的value还是无法被回收,除非线程结束
总结
- 当某个线程的某个threadlocal用完了,马上调用threadlocal的remove方法,就完事
- 如果线程可以及时gc,该泄露问题不大,即泄露时间只在threadlocal最后使用到线程销毁这段时间
- 但是如果线程不会GC(如线程池),而分配者不再调用get、set方法,此时就严重内存泄漏