Java -- 基于JDK1.8的ThreadLocal源码分析

ThreadLocal特性及使用场景：
1、方便同一个线程使用某一对象，避免不必要的参数传递；
2、线程间数据隔离（每个线程在自己线程里使用自己的局部变量，各线程间的ThreadLocal对象互不影响）；
3、获取数据库连接、Session、关联ID（比如日志的uniqueID，方便串起多个日志）；

 1 public void set(T value) {
 2         Thread t = Thread.currentThread();
 3         ThreadLocalMap map = getMap(t);
 4         if (map != null)
 5             map.set(this, value);
 6         else
 7             createMap(t, value);
 8     }
 9 
10 ThreadLocalMap getMap(Thread t) {
11         return t.threadLocals;
12     }
13 
14 void createMap(Thread t, T firstValue) {
15         t.threadLocals = new ThreadLocalMap(this, firstValue);
16     }

public class Thread implements Runnable {
     ThreadLocal.ThreadLocalMap threadLocals = null;
    ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
}

 1 static class Entry extends WeakReference<ThreadLocal<?>> {
 2              /** The value associated with this ThreadLocal. */
 3             Object value;
 4 
 5              Entry(ThreadLocal<?> k, Object v) {
 6                  super(k);
 7                  value = v;
 8              }
 9          }
10  
11          /**
12           * The initial capacity -- MUST be a power of two.
13           */
14          private static final int INITIAL_CAPACITY = 16;
15  
16          /**
17          * The table, resized as necessary.
18           * table.length MUST always be a power of two.
19           */
20          private Entry[] table;
21  
22          /**
23           * The number of entries in the table.
24          */
25          private int size = 0;
26  
27          /**
28           * The next size value at which to resize.
29           */
30          private int threshold; // Default to 0
31  
32  ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
33              table = new Entry[INITIAL_CAPACITY];
34              int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
35              table[i] = new Entry(firstKey, firstValue);
36              size = 1;
37              setThreshold(INITIAL_CAPACITY);
38  }
39 
40 /**
41          * Set the resize threshold to maintain at worst a 2/3 load factor.
42          */
43         private void setThreshold(int len) {
44             threshold = len * 2 / 3;
45         }
46  /**
47          * The next size value at which to resize.
48          */
49         private int threshold; // Default to 0

 1  private void set(ThreadLocal<?> key, Object value) {
 2 
 3             Entry[] tab = table;
 4             int len = tab.length;
 5             int i = key.threadLocalHashCode & (len-1);
 6 
 7             for (Entry e = tab[i];
 8                  e != null;
 9                  e = tab[i = nextIndex(i, len)]) {
10                 ThreadLocal<?> k = e.get();
11 
12                 if (k == key) {
13                     e.value = value;
14                     return;
15                 }
16 
17                 if (k == null) {
18                     replaceStaleEntry(key, value, i);
19                     return;
20                 }
21             }
22 
23             tab[i] = new Entry(key, value);
24             int sz = ++size;
25             if (!cleanSomeSlots(i, sz) && sz >= threshold)
26                 rehash();
27         }

 1  private Entry getEntry(ThreadLocal<?> key) {
 2             int i = key.threadLocalHashCode & (table.length - 1);
 3             Entry e = table[i];
 4             if (e != null && e.get() == key)
 5                 return e;
 6             else
 7                 return getEntryAfterMiss(key, i, e);
 8 }
 9 
10  private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
11             Entry[] tab = table;
12             int len = tab.length;
13 
14             while (e != null) {
15                 ThreadLocal<?> k = e.get();
16                 if (k == key)
17                     return e;
18                 if (k == null)
19                     expungeStaleEntry(i);
20                 else
21                     i = nextIndex(i, len);
22                 e = tab[i];
23             }
24             return null;
25         }

1 private static int nextIndex(int i, int len) {
2     return ((i + 1 < len) ? i + 1 : 0);
3 }

 1  private void remove(ThreadLocal<?> key) {
 2             Entry[] tab = table;
 3             int len = tab.length;
 4             int i = key.threadLocalHashCode & (len-1);
 5             for (Entry e = tab[i];
 6                  e != null;
 7                  e = tab[i = nextIndex(i, len)]) {
 8                 if (e.get() == key) {
 9                     e.clear();
10                     expungeStaleEntry(i);
11                     return;
12                 }
13             }
14         }