本文介绍了ThreadLocal的工作原理，包括ThreadLocalMap的结构和操作，强调ThreadLocal并非解决线程安全问题，而是提供线程隔离的变量。文章还深入探讨了ThreadLocal内存泄漏的原因，指出使用弱引用来防止内存泄漏的必要性，并给出避免内存泄漏的建议：使用完ThreadLocal后调用remove()方法。
1、简介
ThreadLocal提供了一种访问某个变量的特殊方式：访问到的变量属于当前线程，即保证每个线程的变量不一样，而同一个线程在任何地方拿到的变量都是一致的，这就是所谓的线程隔离
ThreadLocalMap并不是为了解决线程安全问题，而是提供了一种将实例绑定到当前线程的机制，类似于隔离的效果，实际上自己在方法中new出来变量也能达到类似的效果。ThreadLocalMap跟线程安全基本不搭边，绑定上去的实例也不是多线程公用的，而是每个线程new一份，这个实例肯定不是共用的，如果共用了，那就会引发线程安全问题。ThreadLocalMap最大的用处就是用来把实例变量共享成全局变量，在程序的任何方法中都可以访问到该实例变量而已。（摘自ThreadLocal使用）
2、ThreadLocal的内部类ThreadLocalMap
（1）主要的结构
可以看到ThreadLocalMap使用Entry来实现key-value的结构，key就是ThreadLocal，value就是存储的值。Entry是一个弱引用。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。
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 static final int INITIAL_CAPACITY = 16;//初始容量
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;
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
table = new Entry[INITIAL_CAPACITY];
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);//获取散列地址
table[i] = new Entry(firstKey, firstValue);//设置key-value
size = 1;//设置初始table中entry的长度
setThreshold(INITIAL_CAPACITY);//设置阀值
}
/**
* 根据parentMap创建ThreadLocalMap
*/
private ThreadLocalMap(ThreadLocalMap parentMap) {
Entry[] parentTable = parentMap.table;
int len = parentTable.length;
setThreshold(len);
table = new Entry[len];
for (int j = 0; j < len; j++) {
Entry e = parentTable[j];
if (e != null) {
@SuppressWarnings("unchecked")
ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
if (key != null) {
Object value = key.childValue(e.value);
Entry c = new Entry(key, value);
int h = key.threadLocalHashCode & (len - 1);
while (table[h] != null)//如果冲突了，使用链地址法寻找下一个地址
h = nextIndex(h, len);
table[h] = c;
size++;
}
}
}
}
}（2）主要方法
①链地址法寻找地址
/**
* 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);
}② 根据key返回对应的entry
步骤：
a.通过传入的key获取哈希地址i，从table取出该entry，如果entry的key与传入的key相同直接返回
b.否则通过getEntryAfterMiss继续寻找 {
b1.如果传入的entry e的key与要找的key相同，直接返回
b2.如果entry的key是null，删除陈旧entry
b3.链地址法寻找下一个哈希地址，更新 e=新entry
b4.如果b3更新的e！=null，重复步骤b1
}
//返回以ThreadLocal作为key的Entry
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);//获取哈希地址
Entry e = table[i];//取出table存放的entry
if (e != null && e.get() == key)//如果entry不为空并且entry的key与寻找的key一致
return e;//返回该entry
else
return getEntryAfterMiss(key, i, e);//没找到key情况下继续尝试寻找
}
/* @param key the thread local object
* @param i the table index for key's hash code
* @param e the entry at table[i]
*/
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)//如果entry的key和要寻找的key相同直接返回
return e;
if (k == null)//如果entry的key是空的，删除过期的entry
expungeStaleEntry(i);
else//否则继续寻找下一个地址
i = nextIndex(i, len);
e = tab[i];//更新entry
}
return null;
}③删除旧的entry
步骤：
a.遍历table，如果entry为null或者entry的key为null，清除陈旧entry
//删除table中所有陈旧的entry
private void expungeStaleEntries() {
Entry[] tab = table;
int len = tab.length;
for (int j = 0; j < len; j++) {
Entry e = tab[j];
if (e != null && e.get() == null)//如果entry不为null并且key为null
expungeStaleEntry(j);//删除指定数组下标的陈旧entry
}
}
步骤：
a.将已经确定为陈旧的staleSolt位置的entry的key及entry置为null，table长度减1
b.从staleSolt往后继续寻找陈旧值（详细看下面代码）
/* @param staleSlot index of slot known to have null key
* @return the index of the next null slot after staleSlot
*/
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;//1.1 entry的value置空
tab[staleSlot] = null;//1.2 entry置空
size--;//1.3 table的entry长度减一
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len);//2.继续遍历寻找过期的值
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {//2.1 key为空 (重复步骤1)
e.value = null;
tab[i] = null;
size--;
} else {//2.2 key不为空，重新计算地址
int h = k.threadLocalHashCode & (len - 1);//获取哈希地址
if (h != i) {//如果不在同一个位置
tab[i] = null;//把老位置的entry置null(删除)
//从h开始往后遍历，一直到找到空为止，插入
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}下面slotToExpunge是最开始需要删除的陈旧的下标，通过往前遍历找到最开始的下标、往后遍历寻找是否可以更新这个下标（如果往前遍历找不到，slotToExpunge值就不会改变，那么根据key是否相同来更新slotToExpunge）。
举个例子，假设我从下面这个table中找key为1的，假设从2开始是staleslot，陈旧下标往前遍历更新了slotToExpunge=0，从后遍历的时候发现slotToExpunge！=staleslot，也就是说原来往前遍历找到了陈旧的entry，这说明不能再找到比它更前的陈旧下标了，所以后面操作都不会更新slotToExpunge了。
步骤：
a.如果找到与传入 key相等的entry，将其与陈旧entry交换，清除陈旧数据，并return
b.如果没找到对应key的entry，清空陈旧entry，并new一个entry放入陈旧位置
c.最后判断一下是否需要清除操作（具体看注释）
//用新元素替换陈旧的元素
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
int slotToExpunge = staleSlot;//需要删除的陈旧元素下标
//1.从陈旧下标往前遍历
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)//如果key为空
slotToExpunge = i;//设置新的需要删除的开始索引
//2.从陈旧下标往后遍历
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
//2.1 如果找到对应的key, 需要将它与陈旧的entry交换来维持哈希表的顺序
// 新的陈旧下标或者其他陈旧下标会通过expungeStaleEntry方法
// 删除或者重新哈希所有的entry
if (k == key) {//2.1.1如果该key值与要替换的key相同
e.value = value;//覆盖旧的value值
//交换
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 从前面的陈旧entry开始删除
if (slotToExpunge == staleSlot)//2.1.2如果slotToExpunge等于传进来的staleSlot，说明在步骤1中没有找到陈旧的entry
slotToExpunge = i;//更新slotToExpunge
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);//2.1.2清除陈旧entry
return;
}
//2.2 如果k是null并且在往后查询的步骤中没有找到过期的entry(也就是步骤2.1.2没有执行过)，更新slotToExpunge
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
//2.3 如果没有找到对应的key，将新的entry放入陈旧的位置
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
//2.4 If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}步骤：
从传入的位置i开始往后寻找清除陈旧entry
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
//往后遍历删除陈旧entry
do {
i = nextIndex(i, len);
Entry e = tab[i];
if (e != null && e.get() == null) {//如果entry不为null并且entry里面的key是null
n = len;
removed = true;
i = expungeStaleEntry(i);//清除陈旧entry
}
} while ( (n >>>= 1) != 0);
return removed;
}④set操作
/**
* Set the value associated with key.
*
* @param key the thread local object
* @param value the value to be set
*/
private void set(ThreadLocal<?> key, Object value) {
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1);//获取元素放置的位置
//从i位置开始往后遍历
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) {
ThreadLocal<?> k = e.get();
if (k == key) {//如果key相等，覆盖原value
e.value = value;
return;
}
if (k == null) {//如果key为null,用新key、value覆盖，同时清理历史key=null的陈旧数据
replaceStaleEntry(key, value, i);
return;
}
}
//ThreadLocal对应的key实例不存在也没有陈旧元素，new 一个
tab[i] = new Entry(key, value);
int sz = ++size;
// // 如果没有清理陈旧的 Entry 并且数组中的元素大于了阈值，则进行rehash
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}
//重新哈希
private void rehash() {
expungeStaleEntries();//清理一次陈旧数据 保证数据及时 GC
// 清理完陈旧数据，如果size >= 3/4阀值,就执行扩容，避免迟滞
if (size >= threshold - threshold / 4)
resize();
}
/**
* 把table扩容2倍，并把老数据重新哈希散列进新table
*/
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
int newLen = oldLen * 2;
Entry[] newTab = new Entry[newLen];
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=null
e.value = null; // 把value也置null,有助于GC回收对象
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);;// 设置新的阈值（实际set方法用了2/3的newLen作为阈值）
size = count;/ 设置ThreadLocalMap的元素个数
table = newTab;// 把新table赋值给ThreadLocalMap的Entry[] table
}⑤remove
/**
* Remove the entry for key.
*/
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();//此处entry的clear实际会把引用置为null(也就是entry的key置null)
expungeStaleEntry(i);//删除陈旧entry
return;
}
}
}
3、ThreadLocal
来看一下ThreadLocal主要的方法:
//返回ThreadLocal的初始值。这个方法将在线程第一次使用{@link #get}方法
//访问变量时调用，除非线程之前调用了{@link #set}方法，
//在这种情况下，将不会为线程调用{@code initialValue}方法
protected T initialValue() {
return null;
}//返回当前线程ThreadLocalMap中ThreadLocal对应的value
public T get() {
Thread t = Thread.currentThread();//获取当前线程
ThreadLocalMap map = getMap(t);//获取线程的ThreadLocalMap变量
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;//不为空直接返回
}
}
return setInitialValue();//为空设置初始值后返回
}
//获取当前线程所对应的ThreadLocalMap
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
private T setInitialValue() {
T value = initialValue();//获取初始值
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);//不为空设置值
else
createMap(t, value);//为空创建ThreadLocalMap
return value;
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)
m.remove(this);//调用ThreadLocalMap删除变量
}4、关于 ThreadLocal内存泄漏问题（摘自【细谈Java并发】谈谈ThreadLocal）
ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用来引用它，那么系统 GC 的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话，这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。
其实，ThreadLocalMap的设计中已经考虑到这种情况，也加上了一些防护措施：在ThreadLocal的get(),set(),remove()的时候都会清除线程ThreadLocalMap里所有key为null的value。
但是这些被动的预防措施并不能保证不会内存泄漏：
- 使用线程池的时候，这个线程执行任务结束，ThreadLocal对象被回收了，线程放回线程池中不销毁，这个线程一直不被使用，导致内存泄漏。
- 分配使用了ThreadLocal又不再调用get(),set(),remove()方法，那么这个期间就会发生内存泄漏。
5、为什么使用弱引用（摘自【细谈Java并发】谈谈ThreadLocal）
从表面上看内存泄漏的根源在于使用了弱引用。网上的文章大多着重分析为什么会内存泄漏，但是另一个问题也同样值得思考：为什么使用弱引用？为什么不用强引用？
我们先来看看官方文档的说法：
To help deal with very large and long-lived usages, the hash table entries use WeakReferences for keys.
为了应对非常大和长时间的用途，哈希表使用弱引用的 key。
下面我们分两种情况讨论：
- key 使用强引用：引用的ThreadLocal的对象被回收了，但是ThreadLocalMap还持有ThreadLocal的强引用，如果没有手动删除，ThreadLocal不会被回收，导致Entry内存泄漏。
- key 使用弱引用：引用的ThreadLocal的对象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使没有手动删除，ThreadLocal也会被回收。value在下一次ThreadLocalMap调用set,get的时候会被清除。
比较两种情况，我们可以发现：由于ThreadLocalMap的生命周期跟Thread一样长，如果都没有手动删除对应key，都会导致内存泄漏，但是使用弱引用可以多一层保障：弱引用ThreadLocal不会内存泄漏，对应的value在下一次ThreadLocalMap调用set,get,remove的时候会被清除。
因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏，而不是因为弱引用。
6、总结（摘自【细谈Java并发】谈谈ThreadLocal）
怎么避免内存泄漏呢？每次使用完ThreadLocal，都调用它的remove()方法，清除数据。
在使用线程池的情况下，没有及时清理ThreadLocal，不仅是内存泄漏的问题，更严重的是可能导致业务逻辑出现问题。所以，使用ThreadLocal就跟加锁完要解锁一样，用完就清理。
扫一扫
943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
