在ThreadLocal的get(),set()的时候都会清除线程ThreadLocalMap里所有key为null的value。
而ThreadLocal的remove()方法会先将Entry中对key的弱引用断开，设置为null，然后再清除对应的key为null的value。
本文分析set方法
ThreadLocal类的set方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t); // 获取线程t中的ThreadLocalMap
if (map != null)
map.set(this, value); // 见代码1
else
createMap(t, value); // 创建新的ThreadLocalMap
}可以看到，set()方法中就是map.set()方法是在干实事，深入进去看看。
代码1：
ThreadLocal.ThreadLocalMap类的set方法
private void set(ThreadLocal<?> key, Object value) {
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(); // 通过value来反查key，比较少见的操作，见代码2
if (k == key) { // 在ThreadLocalMap对象中找到了要设置的key，则直接覆盖原来的value
e.value = value;
return;
}
if (k == null) {
replaceStaleEntry(key, value, i); // 见代码8
return;
}
}
tab[i] = new Entry(key, value); // 新增一个Entry节点
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold) // 如果size大于等于threshold，且执行cleanSomeSlots方法（见代码3）返回为false
rehash(); // 执行rehash方法，见代码5
}这里面查找ThreadLocalMap的key，居然是通过value来反查的，比较少见。先看看Entry的定义吧：
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}Entry又是定义在ThreadLocalMap中的静态内部类，继承了WeakReference类，WeakReference类又继承自Reference类，在Reference类中，有一个引用变量：
public abstract class Reference<T> {
private T referent;
}在Entry的构造方法中，构造新的Entry对象，referent变量存储传入的ThreadLocal对象的引用作为key，value则存储真正的值，这样将ThreadLocal对象和value的对应关系给存储下来。
那么我们看到上面的e.get()方法，实际上是调用的Reference类的get方法。
代码2：
Reference类的get方法：
public T get() {
return this.referent;
}很简单的实现，就是返回存储的referent。
接下来先看看要对table进行rehash的条件判断和实际操作
代码3
ThreadLocal.ThreadLocalMap类的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) { // entry不为null且entry中的key为null
n = len;
removed = true;
i = expungeStaleEntry(i); // 见代码4
}
} while ( (n >>>= 1) != 0); // 等价于n=n>>>1，>>>为无符号右移
return removed;
}该方法只是做了几次检查，没有把table整个扫一遍。源码注释的解释是说这样子性能是介于完全不检查（快速但是会遗留内存垃圾）与检查与table长度比例的元素个数（时间复杂度是O(n)）之间的。这里贴出源码注释，如果有更深刻的理解可以探讨一下。
Heuristically scan some cells looking for stale entries. This is invoked when either a new element is added, or another stale one has been expunged. It performs a logarithmic number of scans, as a balance between no scanning (fast but retains garbage) and a number of scans proportional to number of elements, that would find all garbage but would cause some insertions to take O(n) time.
代码4
ThreadLocal.ThreadLocalMap类的expungeStaleEntry方法
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// expunge entry at staleSlot
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--; // 以上代码，将entry的value赋值为null，这样方便GC时将真正value占用的内存给释放出来；将entry赋值为null，size减1，这样这个slot就又可以重新存放新的entry了
// Rehash until we encounter null
Entry e;
int i;
for (i = nextIndex(staleSlot, len); // 从staleSlot后一个index开始向后遍历，直到遇到为null的entry
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
if (k == null) { // 如果entry的key为null，则清除掉该entry
e.value = null;
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) { // key的hash值不等于目前的index，说明该entry是因为有哈希冲突导致向后移动到当前index位置的
tab[i] = null;
// Unlike Knuth 6.4 Algorithm R, we must scan until
// null because multiple entries could have been stale.
while (tab[h] != null) // 对该entry，重新进行hash并解决冲突
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i; // 返回经过整理后的，位于staleSlot位置后的第一个为null的entry的index值
}expungeStaleEntry方法不止清理了staleSlot位置上的entry，还把staleSlot之后的key为null的entry都清理了，并且顺带将一些有哈希冲突的entry给填充回可用的index中。
代码5
ThreadLocal.ThreadLocalMap类的rehash方法
private void rehash() {
expungeStaleEntries(); // 见代码6
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4) // 进行resize的条件更苛刻了，只要大于等于3/4*threshold就进行resize
resize(); // 见代码7
}首先整理table中key为null的entry，然后进行可能的resize操作
代码6
ThreadLocal.ThreadLocalMap类的expungeStaleEntries方法
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且entry的key为null
expungeStaleEntry(j); // 调用代码1.4的expungeStaleEntry方法
}
}这里见到了前面分析过的expungeStaleEntry方法，也就是对table中entry进行清理。
代码7
ThreadLocal.ThreadLocalMap类的resize方法
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) {
e.value = null; // Help the GC
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}resize方法很熟悉了，将table容量翻倍，不过多分析了。
代码8
最后看看ThreadLocal.ThreadLocalMap类的replaceStaleEntry方法
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len); // 从staleSlot位置向前找，找到最先一个需要清理的entry
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len))
{
ThreadLocal<?> k = e.get();
if (k == key) { // 发生这种情况，说明在key本应存储的hash位置和key实际存储位置之间有出现了key为null的entry
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 这两句代码，将要清理的staleSlot位置的entry，和后面发现的因冲突而存储到i位置的两个entry进行对调
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// If key not found, put new entry in stale slot
tab[staleSlot].value = null; // 先将原来entry的value引用断开，再讲新entry放到staleSlot位置中
tab[staleSlot] = new Entry(key, value);
// If there are any other stale entries in run, expunge them
if (slotToExpunge != staleSlot) // 清理其他key为null的entry
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}这个方法比较复杂，逻辑看的有点混乱，大概是清理了一下staleSlot位置的entry，还做了进一步的清理工作，我也有点理不清楚了。如果有错误请各位读者帮忙斧正。
ThreadLocal类的set(T value)方法就分析完了，做了两部分工作，一是把新的value和相对应的threadLocal对象存放进ThreadLocalMap中了，二就是对ThreadLocalMap中key已经为null的entry进行了清理，方便GC来回收这部分内存。
系列文章链接：
ThreadLocal源码分析：（一）set(T value)方法
ThreadLocal源码分析：（二）get()方法
ThreadLocal源码分析：（三）remove()方法
扫一扫
4511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
