ThreadLocal源码分析：（一）set(T value)方法

在ThreadLocal的get(),set()的时候都会清除线程ThreadLocalMap里所有key为null的value。 
而ThreadLocal的remove()方法会先将Entry中对key的弱引用断开，设置为null，然后再清除对应的key为null的value。 
本文分析set方法

系列文章链接：

http://www.cnblogs.com/noodleprince/p/8657399.html

http://www.cnblogs.com/noodleprince/p/8658333.html

http://www.cnblogs.com/noodleprince/p/8659028.html

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