看很多资料说Java8中ThreadLocal使用了虚引用以及set、get、remove会清理ThreadLocalMap中key为null的数据，这样就不会有内存泄露问题。真的是这样吗？如果是真的，key怎么为null的？怎么清理的？想找到答案，还是从源码入手。
一、set，直接定位到ThreadLocalMap.set
1）：
Entry[] tab = table;
int len = tab.length;
int i = key.threadLocalHashCode & (len-1); -- 获取hash对应槽位
for (Entry e = tab[i];
e != null;
e = tab[i = nextIndex(i, len)]) { -- 如果e不为null就获取下一个槽位，如果i=len-1则会再从0开始
ThreadLocal<?> k = e.get(); -- 获取当前槽位的key值
if (k == key) { -- 如果key值相同则直接替换
e.value = value;
return;
}
if (k == null) { -- key == null说明当前线程对ThreadLocal已无关联，但Entry还存在当前槽位中
replaceStaleEntry(key, value, i); -- 清空部分槽位后加入，下面讲
return; -- 满足条件直接返回
}
}
tab[i] = new Entry(key, value); -- 如果没有hash冲突或找到下一个空槽位则直接添加
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold) -- 清空部分槽位并判断size是否到阀值
rehash(); -- 清空key为null的槽位，并增大数组长度
主要流程为：1、获取key的hash对应槽位
2、判断当前槽位是否已被占用，若已被占用，则判断key值是否相同，是则直接替换；否则则判断槽位中的
Entry的key值是否为null，为null则走replaceStaleEntry方法；
key不相同或不为null则一直往下找，直到遇到空槽位或key相同或key值为null的槽位
3、若直接找到为空的槽位，则放入并清空部分槽位并判断是否需要扩容
2）：下面看replaceStaleEntry(key, value, i)逻辑，即添加数据时发生冲突并且冲突数据的key值为null
Entry[] tab = table;
int len = tab.length;
Entry e;
//清理数据的入口
int slotToExpunge = staleSlot; -- 传入的i，即key == null的槽位
for (int i = prevIndex(staleSlot, len); -- 从i位往前遍历数组，i=0时跳到len-1
(e = tab[i]) != null; -- 直到空槽位
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i; -- 空槽位后第一个key为null的槽
for (int i = nextIndex(staleSlot, len); -- 从i往后遍历
(e = tab[i]) != null; -- 直到空槽位
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == key) { -- 如果找到key与传入的key相同，则替换， 并将新值替换到staleSlot位
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
if (slotToExpunge == staleSlot) -- 如果staleSlot之前没有要清除的值，则从i位置开始
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); -- 清除数据
return;
}
if (k == null && slotToExpunge == staleSlot) -- 若果后面有需要清理的数据，但是前面没有，则设置清理点为i
slotToExpunge = i;
}
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
if (slotToExpunge != staleSlot) -- 如果还有需要清理的数据，则走清理逻辑
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
说明：1、找到第一个要清理的槽位位置slotToExpunge，如果有两个及以上的key为null的entry，则调用cleanSomeSlots
2、将要添加的值放到staleSlot位置
3）：expungeStaleEntry逻辑，主要是value=null，释放value和entry，让垃圾收集器回收
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
tab[staleSlot].value = null; -- 释放value
tab[staleSlot] = null; -- 释放entry
size--;
Entry e;
int i;
for (i = nextIndex(staleSlot, len); -- 从i往后遍历直到null
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null; -- 释放value
tab[i] = null; -- 释放entry
size--;
} else { -- 若key不为null
int h = k.threadLocalHashCode & (len - 1);
if (h != i) { -- 如果之前k出现过hash冲突，则将k放入冲突槽位后第一个为null的槽位
tab[i] = null;
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i; --返回为staleSlot后第一个为空的槽位
}
说明：从staleSlot即清理点开始清除key为null的数据并返回下一个空槽位
1)、2）、3）代码可清除插入点前为空的槽位到后为空的槽位之间的key为null的数据，即两个空之间需要清除的entry已清除
4）：cleanSomeSlots逻辑
private boolean cleanSomeSlots(int i, int n) {
boolean removed = false;
Entry[] tab = table;
int len = tab.length;
do {
i = nextIndex(i, len); -- 从i往后遍历
Entry e = tab[i];
if (e != null && e.get() == null) { -- 遇到需要清除的key
n = len; -- 重置n
removed = true;
i = expungeStaleEntry(i); -- 清除i到第一个空槽位之间需要清除的key
}
} while ( (n >>>= 1) != 0); -- 每次循环n减半，即若2^x=len，则循环x+1次
return removed;
}
说明：从i位置遍历x+1个数据，若遇到需清理数据，则清除i到第一个空槽位之间需要清除的数据并重置n，否则退出。由于不是全遍历，所以还会有key=null的entry没有清除
总结：
set逻辑：1、若没有hash冲突，则直接插入，并调用cleanSomeSlots清除部分key为null的entry，若没有数据清除并且达到
扩容阀值，则进行扩容（扩容时会全遍历删除key=null的数据）
2、若有hash冲突：1）：key相同则直接替换value；
2）：若存在entry但是key为null，则将要添加的值插入， 并清理插入点前后两个空槽之间
key为null的数据，若两个空槽之间存在两个及以上个key为null的entry，则调用 cleanSomeSlots清除部分key为null的entry；
3）：若没有key相同或entry.key为null的情况，则插入遍历到的第一个空槽，
并调用cleanSomeSlots清除部分key为null的entry，若没有数据清除并且达到
扩容阀值， 则进行扩容（扩容时会全遍历删除key=null的数据）
二、get，直接定位到ThreadLocalMap.getEntry，直接上源码
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e; -- 没有冲突时直接返回，没有清entry
else
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)
expungeStaleEntry(i); -- 同上，清理i两边空槽之间的key为null的值，
如果有两个及以上的key为null的entry，则调用cleanSomeSlots
else
i = nextIndex(i, len);
e = tab[i];
}
return null;
}
说明：好像也不能全部清理掉
三、remove，直接定位到ThreadLocalMap.remove，直接上源码
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(); -- 找到key并将entry.key设为null
expungeStaleEntry(i); -- 同上，清理i两边空槽之间的key为null的值，
如果有两个及以上的key为null的entry，则调用cleanSomeSlots
return;
}
}
}
说明：不能保证全部清除，但会清除当前key
总结：除了map扩容时会遍历整个数组进行清除外，其他方法都不能保证全部清除掉所有key为null的entry，除非线程本身被垃圾收集器回收，但现在用的最多的还是线程池，虽然大部分entry和value会被清理，但还会有部分一直存在内存中，所以也不能杜绝内存泄露，最好还是用完后手动remove为好。
注：目前版本key=null的entry是由于ThreadLocal在entry中是虚引用，在没有强引用时，会被垃圾垃圾收集器回收，回收掉后，entry中对应的key会为null。
扫一扫
2530
到【灌水乐园】发言
