在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()方法