深入理解 ThreadLocal
介绍
官方介绍:
此类提供线程局部变量。这些变量与它们的正常对应变量不同，因为每个访问一个变量的线程（通过其get或set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是希望将状态与线程关联的类中的私有静态字段（例如，用户ID或事务ID）。
通俗理解:
ThreadLocal 是用来做线程变量隔离的。对应公共变量，当出现在多线程情况下，容易出现数据修改混乱的情况，通常的做法是加锁(Synchronize和Lock)处理，但这样的做法会降低并发性能。还有一种做法是采用ThreadLocal。它是通过空间来换时间。
源码分析
ThreadLocal 类图
ThreadLocal 的类图结构比较简单，它内部维护了一个ThreadLocalMap类，可以把ThreadLocalMap理解为一个map容器。于此同时，Thread对象里面也维护了一个ThreadLocal.ThreadLocalMap属性。
set(T value)
首先通过当前线程拿到ThreadLocalMap对象(Thread 里面有ThreadLocal.ThreadLocalMap属性，ThreadLocalMap 可以理解为一个Map对象)。然后 用当前ThreadLocal 对象为Key,T Value 为value。存入map中。
public void set(T value) {
//拿到当前线程
Thread t = Thread.currentThread();
//通过当前线程拿到ThreadLocalMap 对象
ThreadLocalMap map = getMap(t);
if (map != null)
//将值放入map中。key 为当前的ThreadLocal对象
map.set(this, value);
else
//如果通过 当前线程拿到的ThreadLocalMap对象为空，
//则构造一个新的ThreadLocalMap,然后将value值放入到map中
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
//getMap 拿到的就是ThreadLocalMap对象
return t.threadLocals;
}
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
/**
* The initial capacity -- MUST be a power of two.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* The table, resized as necessary.
* table.length MUST always be a power of two.
*/
private Entry[] table;
/**
* The number of entries in the table.
*/
private int size = 0;
/**
* The next size value at which to resize.
*/
private int threshold; // Default to 0
/**
* Set the resize threshold to maintain at worst a 2/3 load factor.
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
/**
* Increment i modulo len.
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* Decrement i modulo len.
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
.....
}
void createMap(Thread t, T firstValue) {
//构造一个新的ThreadLocalMap对象。最终是将ThreadLocalMap对象赋值给了Thread的属性。
// 所以我们取值的时候，都是通过当前对象来拿到ThreadLocalMap对象，
//然后通过key 来获取value
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
//设置数组大小为16
table = new Entry[INITIAL_CAPACITY];
//通过key 的hash值 然后和数组大小减1进行与操作获得下标
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
//构造一个entry对象赋值给数组
table[i] = new Entry(firstKey, firstValue);
//容量加一
size = 1;
//设置阈值 为初始值的2/3.
setThreshold(INITIAL_CAPACITY);
}
T get()
如果前面的set(T value) 方法看明白的话，那get () 方法也就是很简单了。通过当前线程，拿到它的属性ThreadLocal.ThreadLocalMap对象。然后以当前对象ThreadLocal 为key。来从map中获取value。
public T get() {
Thread t = Thread.currentThread();
//通过当前线程来获取ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
if (map != null) {
//从map 中获取value. key 为当前对象 ThreadLocal
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
//如果通过当前对象获取的ThreadLocalMap对象为空。则构造一个新的map,并返回null.
return setInitialValue();
}
private T setInitialValue() {
//返回初始的null值
T value = initialValue();
Thread t = Thread.currentThread();
//构造一个新的ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
//返回null 值
return value;
}
protected T initialValue() {
return null;
}
内存泄露
我们来看一段ThreadLocal的代码例子。
private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>();
public Response handleRequest(UserInfo userInfo) {
Response response = new Response();
try {
// 1.用户信息set到线程局部变量中
userInfoThreadLocal.set(userInfo);
doHandle();
} finally {
// 3.使用完移除掉
userInfoThreadLocal.remove();
}
return response;
}
//业务逻辑处理
private void doHandle () {
// 2.实际用的时候取出来
UserInfo userInfo = userInfoThreadLocal.get();
//查询用户资产
queryUserAsset(userInfo);
}
面试题: threadLocal 会出现内存溢出问题？
要分析这个问题，我们可以看下ThreadLocal 内存中的引用关系
首先ThreadLocal对象 被ThreadLocal引用 引用着，这是一个强引用。同时，entry 的key 也被ThreadLocal对象引用。此时的引用是个弱引用。
static class ThreadLocalMap {
//Entry 继承于 WeakReference，是个弱引用
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
//Entry 的key 是ThreadLocal对象，正是 Entry 继承的弱引用对象。
// 即entry 的key 也是一个弱引用对象。
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
所以正常情况下，当threadLocal 所在的作用域结束了，工作被清理了。ThreadLocal对象就会被回收(虽然ThreadLocal对象被key引用，但是弱引用，依然会被gc回收)。然后key 就指向了null。
但是我们在使用线程池的情况下，线程使用完毕，不会被回收。所以 从Thread引用–> Thread对象 --> ThreadLocalMap–>Entry 这条引用线一直存在。而且是强引用。这样 Entry中的 value对象就不能被回收了？
此时我们就可以手动回收value对象了。调用 ThreadLocal 的remove方法。
public void remove() {
//获取当前线程的ThreadLocalMap对象
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
//调用ThreadLocalMap对象的remove方法
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) {
e.clear();
//进行数组的元素清理
expungeStaleEntry(i);
return;
}
}
}
其实ThreadLocal 里面的get/set 方法都会删除map 中key 为null的元素。这样可以尽最大努力避免内存泄露。
get 方法会调用 getEntryAfterMiss方法
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. 删除该元素
expungeStaleEntry(i);
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
set 方法会调用 set -->replaceStaleEntry–>cleanSomeSlots 方法
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;
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;
}
//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();
}
hash冲突解决
ThreadLocalMap 的冲突策略和HashMap不一样。HashMap 冲突后，是采用链表方式解决。ThreadLocalMap 如果发生冲突，则将元素放入下一个数组下标。如果超过了阈值，则进行扩容。
总结
ThreadLocal的逻辑不是特别复杂。但面试 问的特别多。希望本文能帮助到大家理解这块的逻辑。特别是涉及到内存泄露这块。
388
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
