您的位置:首页 > 编程语言 > Java开发

Java读源码之ThreadLocal

2019-10-15 22:55 1251 查看

前言

JDK版本: 1.8

之前在看Thread源码时候看到这么一个属性

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal实现的是每个线程都有一个本地的副本,相当于局部变量,其实ThreadLocal就是内部自己实现了一个map数据结构。

ThreadLocal确实很重要,但想到看源码还是有个小故事的,之前去美团点评面试,问我如何保存用户登录token,可以避免层层传递token?

心想这好像是在说ThreadLocal,然后开始胡说放在redis里或者搞个ThreadLocal,给自己挖坑了

面试官继续问,ThreadLocal使用时候主要存在什么问题么?

完蛋,确实只了解过,没怎么用过,凉凉,回来查了下主要存在的问题如下

  • ThreadLocal可能内存泄露?

带着疑惑进入源码吧

源码

类声明和重要属性

package java.lang;

public class ThreadLocal<T> {

// hash值,类似于Hashmap,用于计算放在map内部数组的哪个index上
private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT);}
// 初始0
private static AtomicInteger nextHashCode = new AtomicInteger();
// 神奇的值,这个hash值的倍数去计算index,分布会很均匀,总之很6
private static final int HASH_INCREMENT = 0x61c88647;

static class ThreadLocalMap {

// 注意这是一个弱引用
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;

Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
// 初始容量16,一定要是2的倍数
private static final int INITIAL_CAPACITY = 16;
// map内部数组
private Entry[] table;
// 当前储存的数量
private int size = 0;
// 扩容指标,计算公式 threshold = 总容量 * 2 / 3,默认初始化之后为10
private int threshold;

增改操作

让我们先来看看增改方法

public void set(T value) {
Thread t = Thread.currentThread();
// 拿到当前Thread对象中的threadLocals引用,默认threadLocals值是null
ThreadLocalMap map = getMap(t);
if (map != null)
// 如果ThreadLocalMap已经初始化过,就把当前ThreadLocal实例的引用当key,设置值
map.set(this, value); //下文详解
else
// 如果不存在就创建一个ThreadLocalMap并且提供初始值
createMap(t, value);
}

ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}

void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}

让我们来看看map.set(this, value)具体怎么操作ThreadLocalMap

private void set(ThreadLocal<?> key, Object value) {
// 获取ThreadLocalMap内部数组
Entry[] tab = table;
int len = tab.length;
// 算出需要放在哪个桶里
int i = key.threadLocalHashCode & (len-1);
// 如果当前桶冲突了,这里没有用拉链法,而是使用开放定指法,index递增直到找到空桶,数据量很小的情况这样效率高
for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
// 拿到目前桶中key
ThreadLocal<?> k = e.get();
// 如果桶中key和我们要set的key一样,直接更新值就ok了
if (k == key) {
e.value = value;
return;
}
// 桶中key是null,因为是弱引用,可能被回收掉了,这个时候我们直接占为己有,并且进行cleanSomeSlots,当前key附近局部清理其他key是空的桶
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
// 如果没冲突直接新建
tab[i] = new Entry(key, value);
int sz = ++size;
// 当前key附近局部清理key是空的桶,如果一个也没清除并且当前容量超过阈值了就扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}

private void rehash() {
// 这个方法会清除所有key为null的桶,清理完后size的大小会变小
expungeStaleEntries();

// 此时size还大于阈值的3/4就扩容
if (size >= threshold - threshold / 4)
// 2倍扩容
resize();
}

为什么会内存泄漏

总算读玩了set,大概明白了为什么会发生内存泄漏,画了个图

ThreadLocalMap.Entry中的key保存了ThreadLocal实例的一个弱引用,如果ThreadLocal实例栈上的引用断了,只要GC一发生,就铁定被回收了,此时Entry的key,就是null,但是呢Entry的value是强引用而且是和Thread实例生命周期绑定的,也就是线程没结束,值就一直不会被回收,所以产生了内存泄漏。

总算明白了,为什么一个set操作要这么多次清理key为null的桶。

既然这么麻烦,为什么key一定要用弱引用?

继续看上面的图,如果我们的Entry中保存的是ThreadLocal实例的一个强引用,我们删掉了ThreadLocal栈上的引用,同理此时不仅value就连key也不会回收了,这内存泄漏就更大了

查询操作

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;
}
}
// 返回null
return setInitialValue();
}

private T setInitialValue() {
T value = initialValue();
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
// 如果只是threadLocals.Entry是空,就设置value为null
map.set(this, value);
else
// 如果threadLocals是空,就new 一个key是当前ThreadLocal,value是空的ThreadLocalMap
createMap(t, value);
return value;
}

protected T initialValue() {
return null;
}

让我们来看看map.getEntry(this)具体怎么操作ThreadLocalMap

private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
// 最好情况,定位到了Entry,并且key匹配
return e;
else
// 可能是hash冲突重定址了,也可能是key被回收了
return getEntryAfterMiss(key, i, e);
}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 向后遍历去匹配key,同时清除key为null的桶
while (e != null) {
ThreadLocal<?> k = e.get();
if (k == key)
return e;
if (k == null)
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}

如何避免内存泄漏

新增,查询中无处不在的去清理key为null的Entry,是不是我们就可以放心了,大多数情况是的,但是如果我们在使用线程池,核心工作线程是不会停止的,会重复利用,这时我们的Entry中的value就永远不会被回收了这很糟糕,还好源码作者还没给我提供了remove方法,综上所述,养成良好习惯,只要使用完ThreadLocal,一定要进行remove防止内存泄漏

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) {
// 主要多了这一步,让this.referent = null,GC会提供特殊处理
e.clear();
expungeStaleEntry(i);
return;
}
}
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: