ThreadLocal
ThreadLocal是一个将在多线程中为每一个线程创建单独的变量副本的类; 当使用ThreadLocal来维护变量时, ThreadLocal会为每个线程创建单独的变量副本, 避免因多线程操作共享变量而导致的数据不一致的情况。
ThreadLocal 使用
public class ThreadLocalTest {
private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
private static ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<UserInfo>();
public static void main(String[] args) {
threadLocal.set(Thread.currentThread().getName());
UserInfo userInfo = new UserInfo();
userInfo.setLoginId(Thread.currentThread().getName());
userInfoThreadLocal.set(userInfo);
System.out.println(threadLocal.get());
System.out.println(userInfoThreadLocal.get());
}
}
执行结果
main
UserInfo{loginId='main', userName='null'}
set 方法
public void set(T value) {
Thread t = Thread.currentThread(); //获取当前线程
ThreadLocalMap map = getMap(t); //获取ThreadLocalMap
if (map != null) // 如果ThreadLocalMap 不为空 则调用set 方法
map.set(this, value); // this 代表当前ThreadLocal 对象
else
createMap(t, value); //创建ThreadLocalMap 赋值给当前线程threadLocals 属性 并set 当前ThreadLocal 对象为key 传入的value 作为value
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals; //返回当前线程对象threadLocals 属性
}
ThreadLocalMap 结构
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
ThreadLocalMap是ThreadLocal的内部类，主要有一个Entry数组，Entry的key为ThreadLocal，value为ThreadLocal对应的值。每个线程都有一个ThreadLocalMap类型的threadLocals变量。
ThreadLocalMap # set 方法
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1); //ThreadLocal对象hash 值 与数组长度进行与运算 得到数组下标
for (Entry e = tab[i];
e != null;//当遍历到数组元素为空就退出循环
e = tab[i = nextIndex(i, len)]) { // 循环Entry 数组
ThreadLocal<?> k = e.get(); //拿到Entry 的key
if (k == key) {//判断Entry 的key 是否与 需要存储的key 相等
e.value = value; //如果相等就替换原来的值
return;
}
if (k == null) {//Entry 中的key 为空
replaceStaleEntry(key, value, i); // 该方法会继续寻找传入key的安放位置, 并清理掉key为空的Entry
return;
}
}
//走这里 说明Entry[] 数组不存在 该key
tab[i] = new Entry(key, value); //创建key为key ,value为value Entry 存储在下标为i 的位置
int sz = ++size;//数组大小+1
if (!cleanSomeSlots(i, sz) && sz >= threshold) //sz 大小是否大于阈值
rehash();//扩容
}
- 遍历数组Entry[] 如果找到key 相等的entry ，则替换entry 中value
- 如果遍历Entry [] 遇到key为空的entry,则调用replaceStaleEntry 清除key为空的元素
- 如果未找到相等key 的entry ,则传入的key ,value 创建entry 放置在下标未i 的位置
- 如果数组大小超过阈值，则调用rehash 方法扩容
rehash 方法
private void rehash() {
// 调用expungeStaleEntries方法清理key为空的Entry
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4) //数组大小超过阈值的3/4 则调用resize 进行扩容
resize();
}
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;//新数组大小位旧数组大小的两倍
Entry[] newTab = new Entry[newLen];//创建新Entry 数组 ，数组大小为原数组的两倍
int count = 0;
for (int j = 0; j < oldLen; ++j) {//循环遍历原数组
Entry e = oldTab[j];
if (e != null) {
ThreadLocal<?> k = e.get();
if (k == null) {// 如果存在key 为空的entry 则将entry 中的value 置为空
e.value = null; // Help the GC
} else {
int h = k.threadLocalHashCode & (newLen - 1); //通过key 重新计算entry 的下标
while (newTab[h] != null) // 如果新表的该位置已经有元素，则调用nextIndex方法直到寻找到空位置
h = nextIndex(h, newLen);
newTab[h] = e;// 将元素放在对应位置
count++;
}
}
}
setThreshold(newLen);// 设置新表扩容的阈值
size = count;// 更新size
table = newTab;// table指向新表
}
replaceStaleEntry 方法
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
int slotToExpunge = staleSlot; //记录开始清除元素的位置
//从后往前遍历 直到遇到 Entry 为空
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i; //记录Entry key 为空的最后索引位置
//从前往后遍历 直到遇到 Entry 为空
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//如果传入的key 和 entry 中key 相等 ，则传入的value 替换 entry 中的value
if (k == key) {
e.value = value;
//staleSlot 位置 替换 i 位置元素
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
//slotToExpunge == staleSlot 表示 从 staleSlot 向前遍历 未找到key 为空的元素
if (slotToExpunge == staleSlot)
// 因为原staleSlot的元素已经被放到i位置了，这时位置i前面的元素都不需要清除
slotToExpunge = i;
// 从slotToExpunge位置开始清除key为空的Entry
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// 如果第一次遍历到key为null的元素，并且上面的向前寻找key为null的遍历没有找到，
// 则将slotToExpunge设置为当前的位置
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// If key not found, put new entry in stale slot
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 如果slotToExpunge!=staleSlot，代表除了staleSlot位置还有其他位置的元素需要清除
// 需要清除的定义：key为null的Entry，调用cleanSomeSlots方法清除key为null的Entry
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
- slotToExpunge始终记录着需要清除的元素的最前面的位置（即slotToExpunge前面的元素是不需要清除的）
- 从位置staleSlot向前遍历，直到遇到Entry为空，用staleSlot记录最后一个key为null的索引位置（也就是遍历过位置最前的key为null的位置）
- 从位置staleSlot向后遍历，直到遇到Entry为空，如果遍历到key和入参key相同的，则将入参的value替换掉该Entry的value，并将i位置和staleSlot位置的元素对换（staleSlot位置较前，是要清除的元素），遍历的时候判断slotToExpunge的值是否需要调整，最后调用expungeStaleEntry方法和cleanSomeSlots方法清除key为null的元素。
- 如果key没有找到，则使用入参的key和value新建一个Entry，放在staleSlot位置判断是否还有其他位置的元素key为null，如果有则调用expungeStaleEntry方法和cleanSomeSlots方法清除key为null的元素
cleanSomeSlots 方法
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
do {
i = nextIndex(i, len);
Entry e = tab[i];
if (e != null && e.get() == null) { //循环遍历 key 为空的元素
n = len;//重新设置n 的值
removed = true;//设置移除元素标志位
i = expungeStaleEntry(i);//
}
} while ( (n >>>= 1) != 0);
return removed;
}
expungeStaleEntry 方法
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null; //将tab staleSlot 位元素清空
tab[staleSlot] = null;
size--;
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len); // 遍历下一个元素
(e = tab[i]) != null; // 遍历到Entry为空时, 跳出循环并返回索引位置
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) { // 当前遍历Entry的key为空, 则将该位置的对象清空
e.value = null;
tab[i] = null;
size--;
} else { // 当前遍历Entry的key不为空
int h = k.threadLocalHashCode & (len - 1); // 重新计算该Entry的索引位置
if (h != i) { // 如果索引位置不为当前索引位置i
tab[i] = null; // 则将i位置对象清空, 替当前Entry寻找正确的位置
// 如果h位置不为null，则向后寻找当前Entry的位置
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
get 方法
public T get() {
Thread t = Thread.currentThread(); //获取当前线程
ThreadLocalMap map = getMap(t);// 通过当前线程获取 threadLocals = ThreadLocalMap
if (map != null) {//ThreadLocalMap 不为空
ThreadLocalMap.Entry e = map.getEntry(this);//通过ThreadLocal 获取 entry
if (e != null) {//entry 不为空
@SuppressWarnings("unchecked")
T result = (T)e.value; //获取entry value 返回
return result;
}
}
// 该线程的ThreadLocalMap为空，或者没有找到目标Entry，则调用setInitialValue方法
return setInitialValue();
}
- 和set 方法一样先获取当前线程，在获取当前线程的变量threadLocals
- 如果threadLocals 不为空，则通过当前对象ThreadLocal 作为key getEntry 方法获取value 值
- 如果threadLocals 为空，则通过setInitialValue方法初始化一个threadLocal 为key value 值为空的entry 设置在 ThreadLocalMap 中。
getEntry 方法
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1); //通过threadLocal hashcode 与Entry数组长度进行与运算，得到数组下标
Entry e = table[i];
if (e != null && e.get() == key)//如果entry 不为空，key与传入key 相等 返回entry
return e;
else
// 否则，e不是目标Entry, 则从e之后继续寻找目标Entry
return getEntryAfterMiss(key, i, e);
}
getEntryAfterMiss 方法
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
while (e != null) {
ThreadLocal<?> k = e.get();
// 找到目标Entry，直接返回
if (k == key)
return e;
// 调用expungeStaleEntry清除key为null的元素
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len); // 下一个索引位置
e = tab[i]; // 下一个遍历的Entry
}
return null; // 找不到, 返回空
}
setInitialValue 方法
private T setInitialValue() {
T value = initialValue(); //初始化value value =null
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);//获取当前线程的threadLocals 属性
// threadLocals不为空则将当前的ThreadLocal作为key，null作为value，插入到ThreadLocalMap
if (map != null)
map.set(this, value);
else
// 调用set方法的ThreadLocal和value作为该Entry的key和value
createMap(t, value);
return value;
}
remove 方法
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());//获取当前线程的threadLocals 属性
if (m != null)//ThreadLocalMap 不为空
m.remove(this);
}
private void remove(ThreadLocal<?> key) {
Entry[] tab = table;
int len = tab.length;
// 根据hashCode计算出当前ThreadLocal的索引位置
int i = key.threadLocalHashCode & (len-1);
// 从位置i开始遍历，直到Entry为null
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
if (e.get() == key) { // 如果找到key相同的
e.clear(); // 则调用clear方法, 该方法会把key的引用清空
expungeStaleEntry(i);//调用expungeStaleEntry方法清除key为null的Entry
return;
}
}
总结
- 每个线程都有一个ThreadLocalMap 类型的 threadLocals 属性。
- ThreadLocalMap 类相当于一个Map，key 是 ThreadLocal 本身，value 就是我们的值。
- 当我们通过 threadLocal.set(new Integer(123)); 我们就会在这个线程中的 threadLocals属性中放入一个键值对，key 是 这个 threadLocal.set(newInteger(123))的threadlocal，value 就是值new Integer(123)。 当我们通过threadlocal.get() 方法的时候，首先会根据这个线程得到这个线程的 threadLocals属性，然后由于这个属性放的是键值对，我们就可以根据键 threadlocal 拿到值。 注意，这时候这个键 threadlocal 我们 set 方法的时候的那个键 threadlocal 是一样的，所以我们能够拿到相同的值。
- ThreadLocalMap 的get/set/remove方法跟HashMap的内部实现都基本一样，通过 "key.threadLocalHashCode & (table.length - 1)"运算式计算得到我们想要找的索引位置，如果该索引位置的键值对不是我们要找的，则通过nextIndex方法计算下一个索引位置，直到找到目标键值对或者为空。
- hash冲突：在HashMap中相同索引位置的元素以链表形式保存在同一个索引位置；而在ThreadLocalMap中，没有使用链表的数据结构，而是将（当前的索引位置+1）对length取模的结果作为相同索引元素的位置：源码中的nextIndex方法，可以表达成如下公式：如果i为当前索引位置，则下一个索引位置 = (i + 1 < len) ? i + 1 : 0。
ThreadLocal 为啥会发生内存泄漏呢？
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
有源代码可以看出，Entry 中的key ThreadLocal 是 弱引用，如果一个ThreadLocal没有外部强引用来引用它，下一次系统GC时，这个ThreadLocal必然会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value。
如果当前线程一直在运行，并且一直不执行get、set、remove方法，这些key为null的Entry的value就会一直存在一条强引用练：Thread Ref -> Thread -> ThreadLocalMap -> Entry -> value，导致这些key为null的Entry的value永远无法回收，造成内存泄漏。
如何解决内存泄漏
为了避免这种情况，我们可以在使用完ThreadLocal后，手动调用remove方法，以避免出现内存泄漏。
扫一扫
1719
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
