在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来回收这部分内存。