ThreadLocal学习笔记
一、ThreadLocal是什么
- ThrealLocal是jdk1.2就有的一个类,主要是一个线程本地变量
- 同一个ThreadLocal对象在不同的线程中维护了不同的副本
- 由于每个不同线程会维护相同对象的不同副本,所以不存在变量共享的问题
二、ThreadLocal有什么用
- 可以用来做数据隔离
- 最经典的就是spring的事务隔离就是用ThreadLocal隔离了Connection
三、ThreadLocal的数据结构
- 每个Thread里都维护了一个threadLocals对象,他是ThreadLocalMap类型的
- 每次操作ThreadLocal(get、set、remove)变量时,就会去访问threadLocals对象,
- ThreadLocalMap是ThreadLocal的一个内部类,没有实现Map接口,内部是一个继承WeakReference的Entry,初始大小也是16,因为同一个线程可能有多个ThreadLocal对象,所以内部需要一个Entry数组,每个不同的ThreadLocal对象对应着不同的Entry。
- Entry的key是ThreadLocal本身,是一个弱引用,在发生GC的时候便于回收,但要是没有使用得当也会产生内存泄露的问题
- ThreadLocal有threadLocalHashCode成员变量自己维护的hashCode,定位Entry时也是通过这个变量来寻找数组的下标
大致的数据结构图就是这样
四、ThreadLocal源码解析
set方法解析
- 获取当前线程以及当前线程的threadLocals的Map对象
- map为空就new一个Map,并且初始化容量、resize阈值,并set第一个key,value等
- 当调用ThreadLocalMap的set方法发现有发生过GC的话,就会对整个entry进行一次replaceStaleEntry,更新key为null的entry,把他们的entry本身、entry的value都置为null,然后rehash
public void set(T value) {
//当前线程
Thread t = Thread.currentThread();
//当前线程维护的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
//调用ThreadLocalMap的set方法
map.set(this, value);
else
//初始化ThreadLocalMap并存入第一个值
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//ThreadLocalMap的set方法
private void set(ThreadLocal<?> key, Object value) {
// We don't use a fast path as with get() because it is at
// least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast
// path would fail more often than not.
Entry[] tab = table;
int len = tab.length;
//通过threadLocalHashCode找到Entry数组的下标
int i = key.threadLocalHashCode & (len-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;
}
//个人理解为被GC了,所以entry不是null,但是key为null了,因为弱引用
//清除当前entry数组中所有的entry
if (k == null) {
//将废弃的entry都更新为null entry(null,null)
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
get方法解析
- 同样先获取当前线程和当前线程的ThreadLocalMap
- map不为空的话就去getEntry
- map为空的话会先初始化ThreadLocalMap,包括初始化16大小entry数组,resize阈值大小,已经第一个key,value
- 调用getEntry方法通过hashCode定位到entry数组的下标,获取到就直接返回entry,否则会把从当前位置开始到下一个key为null之前的所有entry都置为null,然后rehash
public T get() {
//还是获取当前线程
Thread t = Thread.currentThread();
//以及当前线程的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
if (map != null) {
//getEntry方法传入的this
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//初始化当前Thread的Map
return setInitialValue();
}
private Entry getEntry(ThreadLocal<?> key) {
//通过当前对象的hashCode定位到entry的下标
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
//找到就直接返回
return e;
else
//reHash当前位置直到下一个null entry之前的数据
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)
//rehash当前null数据直到下一个不为null之前的数据
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
private T setInitialValue() {
//protected方法,可自己实现,默认是null
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
//调用构造方法初始化,包括初始化大小为16的Entry数组
//设置第一个entry(key,value)
//设置resize的阈值为容量的2/3
createMap(t, value);
return value;
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
setThreshold(INITIAL_CAPACITY);
}
expungeStaleEntry方法
- 主要的清除空entry的方法
- rehash的方法
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) {
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
remove方法解析
- 都是先获取当前线程的Map
- 然后调用map的remove方法
- remove方法里先是定位到entry下标,然后循环遍历entry数组(不理解为啥定位到了下标还要循环遍历数组),分别清除key的软引用,value和entry,然后rehash
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);
}
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的软引用
e.clear();
//清除value和entry,rehash
expungeStaleEntry(i);
return;
}
}
}
五、注意事项
- 因为ThreadLocalMap中的Entry是一个弱引用,但是Entry的value是一个强引用,使用完需要remove掉,不然会导致内存泄露
- ThreadLocalMap并没有像HashMap用链表和红黑树来解决冲突,只是通过遍历空的位置来插入新的entry,所以冲突多的话,遍历的开销是有的