ThreadLocal类

 1 /**
 2          * Construct a new map initially containing (firstKey, firstValue).
 3          * ThreadLocalMaps are constructed lazily, so we only create
 4          * one when we have at least one entry to put in it.
 5          */
 6         ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
 7             table = new Entry[INITIAL_CAPACITY];
 8             int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
 9             table[i] = new Entry(firstKey, firstValue);
10             size = 1;
11             setThreshold(INITIAL_CAPACITY);
12         }

Thread.java
//其他代码

/* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
//其他代码

ThreadLocal.java
//其他代码

/**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

//其他代码

 1 /**
 2          * The table, resized as necessary.
 3          * table.length MUST always be a power of two.
 4          */
 5         private Entry[] table;
 6 
 7 
 8 /**
 9          * The entries in this hash map extend WeakReference, using
10          * its main ref field as the key (which is always a
11          * ThreadLocal object).  Note that null keys (i.e. entry.get()
12          * == null) mean that the key is no longer referenced, so the
13          * entry can be expunged from table.  Such entries are referred to
14          * as "stale entries" in the code that follows.
15          */
16         static class Entry extends WeakReference<ThreadLocal<?>> {
17             /** The value associated with this ThreadLocal. */
18             Object value;
19 
20             Entry(ThreadLocal<?> k, Object v) {
21                 super(k);
22                 value = v;
23             }
24         }

 1  /**
 2      * Sets the current thread‘s copy of this thread-local variable
 3      * to the specified value.  Most subclasses will have no need to
 4      * override this method, relying solely on the {@link #initialValue}
 5      * method to set the values of thread-locals.
 6      *
 7      * @param value the value to be stored in the current thread‘s copy of
 8      *        this thread-local.
 9      */
10     public void set(T value) {
11         Thread t = Thread.currentThread();
12         ThreadLocalMap map = getMap(t);
13         if (map != null) {
14             map.set(this, value);
15         } else {
16             createMap(t, value);
17         }
18     }

 1 /**
 2          * Set the value associated with key.
 3          *
 4          * @param key the thread local object
 5          * @param value the value to be set
 6          */
 7         private void set(ThreadLocal<?> key, Object value) {
 8 
 9             // We don‘t use a fast path as with get() because it is at
10             // least as common to use set() to create new entries as
11             // it is to replace existing ones, in which case, a fast
12             // path would fail more often than not.
13 
14             Entry[] tab = table;
15             int len = tab.length;
16             int i = key.threadLocalHashCode & (len-1);
17 
18             for (Entry e = tab[i];
19                  e != null;
20                  e = tab[i = nextIndex(i, len)]) {
21                 ThreadLocal<?> k = e.get();
22 
23                 if (k == key) {
24                     e.value = value;
25                     return;
26                 }
27 
28                 if (k == null) {
29                   //key == null，但是存在值（因为此处的e != null），说明之前的ThreadLocal对象已经被回收了
30                     replaceStaleEntry(key, value, i);
31                     return;
32                 }
33             }
34 
35             tab[i] = new Entry(key, value);
36             int sz = ++size;
37            //cleanSomeSlots(i, sz) 方法用于清除key为Null的entry
38             if (!cleanSomeSlots(i, sz) && sz >= threshold)
39                 rehash();
40         }