ThreadLocal的使用及原理

public class ThreadLocalTest {

 //定义一个ThreadLocal的变量, 需要指定类型
 public static ThreadLocal<String> threadLocal = new InheritableThreadLocal<>();

 @Before
 public void init(){
 #set值进去
 threadLocal.set("test");
 }

 @Test
 public void test() {
 //在需要时get出来
 System.out.println("threadLocal's value=" + threadLocal.get());
 }

}

public void set(T value) {
       //取出当前线程
       Thread t = Thread.currentThread();
       //根据当前线程获取ThreadLocalMap。从getMap方法可以看到这个ThreadLocalMap就是保存在Thread对象里面
       ThreadLocalMap map = getMap(t);
       if (map != null）
 #map已经存在就是set进去
 map.set(this, value);
       else
 #不存在新建一个map
 createMap(t, value);
 }

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

   //createMap方法
   //注意，这里的this指的是ThreadLocal对象
   void createMap(Thread t, T firstValue) {
 t.threadLocals = new ThreadLocalMap(this, firstValue);
 }

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
 table = new Entry[INITIAL_CAPACITY];
 //通过ThreadLocal的hashCode确定index，这个我们稍后再说
 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
 //重点，把ThreadLocal对象作为key存到了ThreadLocalMap的Entry里
 table[i] = new Entry(firstKey, firstValue);
 size = 1;
 setThreshold(INITIAL_CAPACITY);
 }

private void set(ThreadLocal<?> key, Object value) {

 // We don't use a fast path as with get() because it is at
 // least as common to use set() to create new entries as
 // it is to replace existing ones, in which case, a fast
 // path would fail more often than not.

 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();
 }

public T get() {
 //取当前线程
 Thread t = Thread.currentThread();
 //取出线程的ThreadLocalMap，跟上面是一样的
 ThreadLocalMap map = getMap(t);
 if (map != null) {
 //根据当前对象ThreadLocal取出ThreadLocalMap.Entry
 ThreadLocalMap.Entry e = map.getEntry(this);
 if (e != null) {
 @SuppressWarnings("unchecked")
 T result = (T)e.value;
 return result;
 }
 }
 //如果map为null则做初始化，跟上面的createMap差不多
 return setInitialValue();
 }

//对key使用了WeakReference
static class Entry extends WeakReference<ThreadLocal<?>> {
 /** The value associated with this ThreadLocal. */
 Object value;
 Entry(ThreadLocal<?> k, Object v) {
 super(k);
 value = v;
 }
 }

/**
 * Expunge a stale entry by rehashing any possibly colliding entries
 * lying between staleSlot and the next null slot.  This also expunges
 * any other stale entries encountered before the trailing null.  See
 * Knuth, Section 6.4
 *
 * @param staleSlot index of slot known to have null key
 * @return the index of the next null slot after staleSlot
 * (all between staleSlot and this slot will have been checked
 * for expunging).
 */
 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;
 }

//table的下标的计算方式
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);

//threadLocalHashCode的定义
private final int threadLocalHashCode = nextHashCode();

private static int nextHashCode() {
 return nextHashCode.getAndAdd(HASH_INCREMENT);
 }

 /**
 * The difference between successively generated hash codes - turns
 * implicit sequential thread-local IDs into near-optimally spread
 * multiplicative hash values for power-of-two-sized tables.
 */
   //HASH_INCREMENT的十进制为1640531527
   private static final int HASH_INCREMENT = 0x61c88647;

public FastThreadLocal() {
 index = InternalThreadLocalMap.nextVariableIndex();
 }

 public static int nextVariableIndex() {
 int index = nextIndex.getAndIncrement();
 if (index < 0) {
 nextIndex.decrementAndGet();
 throw new IllegalStateException("too many thread-local indexed variables");
 }
 return index;
 }