ThreadLocal源码解析

---

ThreadLocal的源码简单易懂，很适合新手学习。现在我们一起来学习一下。

什么是ThreadLocal？

顾名思义，ThreadLocal可以理解为一个线程本地变量池。所有线程都能往里面放东西并且互不干扰。也就是说，定义一个ThreadLocal后，每一个线程对它进行的操作都是线程隔离的，它通过将可变数据通过每个线程有的独立副本进行保存，从而实现线程封闭。

大致的实现思路是什么样的？

Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。

每个线程在往某个ThreadLocal里塞值的时候，都会往自己的ThreadLocalMap里存，读也是以某个ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

几个重要的API

• 向当前线程中的ThreadLocalMap中存入数据
  • Public Set(T Value)

Public void set(Tvalue){
  Thread t = Thread.currentThread();  //获得当前线程
  ThreadLocalMap map=getMap(t);       //通过线程引用获得对应的ThreadLocalMap
  if(map!=null)                       //判断map是否存在，存数据或者新建map
    map.set(this,value);            //这里是this，不是t
  else
    createMap(t,value);
}

ThreadLocalMap getMap (Thread t){
  return t.threadLocals;
}

Void createMap (Thread t,T firstValue){
  t.threadLocals = new ThreadLocalMap(this,firstValue);
}

• 获取当前进程存入的数据。
  • Public T get()

Public T get(){
  Thread t = Thread.currentThread();
  ThreadLocalMap map = getMap(t);
  if(map != null){
    ThreadLocalMap.Entrye = map.getEntry(this); //通过this获取数据（其实是通过Hashcode）
    if(e != null){
      @SuppressWarnings("unchecked")
      T result = (T)e.value;
      return result;
    }
  }
  return setInitialValue(); //返回null 进入初始化
}

为什么要用弱引用?

因为如果这里使用普通的key-valu形式来定义存储结构，实质上就会造成节点的生命周期与线程强绑定，只要线程没有销毁，那么节点在GC分析中一直处于可达状态，没办法被回收，而程序本身也无法判断是否可以清理节点。弱引用是Java中四档引用的第三档，比软引用更加弱一些，如果一个对象没有强引用链可达，那么一般活不过下一次GC。当某个ThreadLocal已经没有强引用可达，则随着它被垃圾回收，在ThreadLocalMap里对应的Entry的键值会失效，这为ThreadLocalMap本身的垃圾清理提供了便利。（我们可以试着用软引用实现一个高速缓存，在我另一篇博文中会详细描述）

从上文的get()方法中我们可以看到，当调用时，会从当前线程中返回ThreadLocalMap，如果返回为null会调用setInitialValue()进行初始化操作：

private T setInitialValue() {
     T value = initialValue();
     Thread t = Thread.currentThread();
     ThreadLocalMap map = getMap(t);
     if (map != null)
         map.set(this, value);
     else
         createMap(t, value);
     return value;
 }
 ...
 protected T initialValue() {
       return null;
   }
 ...

我们可以看出，初始化操作就是判断线程是否含有ThreadLocalMap，如果有就将null插入其中占位，如果没有就创建：

void createMap(Thread t, T firstValue) {
      t.threadLocals = new ThreadLocalMap(this, firstValue);
  }

所看出，正真实现线程线程本地变量池的其实是ThreadLocalMap，我们下面具体分析一下ThreadLocalMap。

//ThreadLocalMap是一个静态内部类
static class ThreadLocalMap {

       //map中存放的结点信息，包括一个k(设为引用),Value
       //这里通过继承WeakReference使用弱引用作为键值巧妙的解决了内存释放问题，大师真的是厉害！
       static class Entry extends WeakReference<ThreadLocal<?>> {
           Object value;
           Entry(ThreadLocal<?> k, Object v) {
               super(k);
               value = v;
           }
       }

       //初始容量，必须是2的次方
       //为什么？这里有一个数学问题，和奇妙的0x61c88647有关，我讲不太明白，请自行百度
       private static final int INITIAL_CAPACITY = 16;

       //结点数组
       private Entry[] table;

       /**
        * The number of entries in the table.
        */
       private int size = 0;

       /**
        * The next size value at which to resize.
        */
       private int threshold; // Default to 0

       /**
        * Set the resize threshold to maintain at worst a 2/3 load factor.
        */
        //为什么是三分之二？请自行百度
       private void setThreshold(int len) {
           threshold = len * 2 / 3;
       }

       /**
        * Increment i modulo len.
        */
       private static int nextIndex(int i, int len) {
           return ((i + 1 < len) ? i + 1 : 0);
       }

       /**
        * Decrement i modulo len.
        */
       private static int prevIndex(int i, int len) {
           return ((i - 1 >= 0) ? i - 1 : len - 1);
       }

       //敲黑板，请画重点
       //初始化table，并通过&运算计算出存放位置
       //这里firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)我在后文单独解释一下
       ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
           table = new Entry[INITIAL_CAPACITY];
           int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
           table[i] = new Entry(firstKey, firstValue);
           size = 1;
           setThreshold(INITIAL_CAPACITY);//计算扩容的标准
       }

       //通过parentMap获得一个ThreadLocal子类ThreadLocalMap，想用这个方法，你得在自己的实现中重写childValue()方法
       private ThreadLocalMap(ThreadLocalMap parentMap) {
           Entry[] parentTable = parentMap.table;
           int len = parentTable.length;
           setThreshold(len);
           table = new Entry[len];

           for (int j = 0; j < len; j++) {
               Entry e = parentTable[j];
               if (e != null) {
                   @SuppressWarnings("unchecked")
                   ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                   if (key != null) {
                       Object value = key.childValue(e.value);
                       Entry c = new Entry(key, value);
                       int h = key.threadLocalHashCode & (len - 1);
                       while (table[h] != null)
                           h = nextIndex(h, len);
                       table[h] = c;
                       size++;
                   }
               }
           }
       }

       //通过key计算地址并取出值
       private Entry getEntry(ThreadLocal<?> key) {
           int i = key.threadLocalHashCode & (table.length - 1);
           Entry e = table[i];
           if (e != null && e.get() == key)
               return e;
           else
               return getEntryAfterMiss(key, i, e);
       }

       //当找不到key对应的结点或者找到的结点对应的引用和key对应的引用不一致时调用
       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);
               else
                   i = nextIndex(i, len);
               e = tab[i];
           }
           return null;
       }


       //set新的数据，这里对找不到key的情况进行了处理（原来没处理的版本会造成内存泄漏），对脏数据进行了清除
       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();

               if (k == key) {
                   e.value = value;
                   return;
               }

               if (k == null) {
                   replaceStaleEntry(key, value, i);
                   return;
               }
           }

           tab[i] = new Entry(key, value);
           int sz = ++size;
           if (!cleanSomeSlots(i, sz) && sz >= threshold)
               rehash();
       }

       //以前用完之后不进行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();
                   expungeStaleEntry(i);
                   return;
               }
           }
       }

       //清理脏数据，请自行研究，画个线型图更清除哦
       private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                      int staleSlot) {
           Entry[] tab = table;
           int len = tab.length;
           Entry e;

           // Back up to check for prior stale entry in current run.
           // We clean out whole runs at a time to avoid continual
           // incremental rehashing due to garbage collector freeing
           // up refs in bunches (i.e., whenever the collector runs).
           int slotToExpunge = staleSlot;
           for (int i = prevIndex(staleSlot, len);
                (e = tab[i]) != null;
                i = prevIndex(i, len))
               if (e.get() == null)
                   slotToExpunge = i;

           // Find either the key or trailing null slot of run, whichever
           // occurs first
           for (int i = nextIndex(staleSlot, len);
                (e = tab[i]) != null;
                i = nextIndex(i, len)) {
               ThreadLocal<?> k = e.get();

               // If we find key, then we need to swap it
               // with the stale entry to maintain hash table order.
               // The newly stale slot, or any other stale slot
               // encountered above it, can then be sent to expungeStaleEntry
               // to remove or rehash all of the other entries in run.
               if (k == key) {
                   e.value = value;

                   tab[i] = tab[staleSlot];
                   tab[staleSlot] = e;

                   // Start expunge at preceding stale entry if it exists
                   if (slotToExpunge == staleSlot)
                       slotToExpunge = i;
                   cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                   return;
               }

               // If we didn't find stale entry on backward scan, the
               // first stale entry seen while scanning for key is the
               // first still present in the run.
               if (k == null && slotToExpunge == staleSlot)
                   slotToExpunge = i;
           }

           // If key not found, put new entry in stale slot
           tab[staleSlot].value = null;
           tab[staleSlot] = new Entry(key, value);

           // If there are any other stale entries in run, expunge them
           if (slotToExpunge != staleSlot)
               cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
       }

       //从当前脏entry位置到返回的i位中间所有的脏entry
       private int expungeStaleEntry(int staleSlot) {
           Entry[] tab = table;
           int len = tab.length;

           // expunge entry at staleSlot
           tab[staleSlot].value = null;
           tab[staleSlot] = null;
           size--;

           // Rehash until we encounter null
           Entry e;
           int i;
           for (i = nextIndex(staleSlot, len);
                (e = tab[i]) != null;
                i = nextIndex(i, len)) {
               ThreadLocal<?> k = e.get();
               if (k == null) {
                   e.value = null;
                   tab[i] = null;
                   size--;
               } else {
                   int h = k.threadLocalHashCode & (len - 1);
                   if (h != i) {
                       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)
                           h = nextIndex(h, len);
                       tab[h] = e;
                   }
               }
           }
           return i;
       }


       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) {
                   n = len;
                   removed = true;
                   i = expungeStaleEntry(i);
               }
           } while ( (n >>>= 1) != 0);
           return removed;
       }

       /**
        * Re-pack and/or re-size the table. First scan the entire
        * table removing stale entries. If this doesn't sufficiently
        * shrink the size of the table, double the table size.
        */
       private void rehash() {
           expungeStaleEntries();

           // Use lower threshold for doubling to avoid hysteresis
           if (size >= threshold - threshold / 4)
               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;
       }

       //清理脏数据
       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)
                   expungeStaleEntry(j);
           }
       }
   }

firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)这句的目的是计算位置，因为INITIAL_CAPACITY必须是2的次方所以INITIAL_CAPACITY - 1必定是一个形如0x00000111的数字，与前半部分的哈希值相&就会得到一个极大概率不会冲突的地址。