聊一聊Spring中的线程安全性

 1 /**
 2      * ThreadLocalMap is a customized hash map suitable only for
 3      * maintaining thread local values. No operations are exported
 4      * outside of the ThreadLocal class. The class is package private to
 5      * allow declaration of fields in class Thread.  To help deal with
 6      * very large and long-lived usages, the hash table entries use
 7      * WeakReferences for keys. However, since reference queues are not
 8      * used, stale entries are guaranteed to be removed only when
 9      * the table starts running out of space.
10      */
11     static class ThreadLocalMap {
12         /**
13          * The entries in this hash map extend WeakReference, using
14          * its main ref field as the key (which is always a
15          * ThreadLocal object).  Note that null keys (i.e. entry.get()
16          * == null) mean that the key is no longer referenced, so the
17          * entry can be expunged from table.  Such entries are referred to
18          * as "stale entries" in the code that follows.
19          */
20         static class Entry extends WeakReference<ThreadLocal<?>> {
21             /** The value associated with this ThreadLocal. */
22             Object value;
23 
24             Entry(ThreadLocal<?> k, Object v) {
25                 super(k);
26                 value = v;
27             }
28         }
29         ....
30     }

 1  /**
 2      * ThreadLocals rely on per-thread linear-probe hash maps attached
 3      * to each thread (Thread.threadLocals and
 4      * inheritableThreadLocals).  The ThreadLocal objects act as keys,
 5      * searched via threadLocalHashCode.  This is a custom hash code
 6      * (useful only within ThreadLocalMaps) that eliminates collisions
 7      * in the common case where consecutively constructed ThreadLocals
 8      * are used by the same threads, while remaining well-behaved in
 9      * less common cases.
10      */
11     private final int threadLocalHashCode = nextHashCode();
12 
13     /**
14      * The next hash code to be given out. Updated atomically. Starts at
15      * zero.
16      */
17     private static AtomicInteger nextHashCode =
18         new AtomicInteger();
19 
20     /**
21      * The difference between successively generated hash codes - turns
22      * implicit sequential thread-local IDs into near-optimally spread
23      * multiplicative hash values for power-of-two-sized tables.
24      */
25     private static final int HASH_INCREMENT = 0x61c88647;
26 
27     /**
28      * Returns the next hash code.
29      */
30     private static int nextHashCode() {
31         return nextHashCode.getAndAdd(HASH_INCREMENT);
32     }

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

 1 /**
 2      * Returns the value in the current thread‘s copy of this
 3      * thread-local variable.  If the variable has no value for the
 4      * current thread, it is first initialized to the value returned
 5      * by an invocation of the {@link #initialValue} method.
 6      *
 7      * @return the current thread‘s value of this thread-local
 8      */
 9     public T get() {
10         Thread t = Thread.currentThread();
11         ThreadLocalMap map = getMap(t);
12         if (map != null) {
13             ThreadLocalMap.Entry e = map.getEntry(this);
14             if (e != null) {
15                 @SuppressWarnings("unchecked")
16                 T result = (T)e.value;
17                 return result;
18             }
19         }
20         return setInitialValue();
21     }
22 
23     /**
24      * Variant of set() to establish initialValue. Used instead
25      * of set() in case user has overridden the set() method.
26      *
27      * @return the initial value
28      */
29     private T setInitialValue() {
30         T value = initialValue();
31         Thread t = Thread.currentThread();
32         ThreadLocalMap map = getMap(t);
33         if (map != null)
34             map.set(this, value);
35         else
36             createMap(t, value);
37         return value;
38     }
39 
40     protected T initialValue() {
41         return null;
42     }

 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 
19     /**
20      * Removes the current thread‘s value for this thread-local
21      * variable.  If this thread-local variable is subsequently
22      * {@linkplain #get read} by the current thread, its value will be
23      * reinitialized by invoking its {@link #initialValue} method,
24      * unless its value is {@linkplain #set set} by the current thread
25      * in the interim.  This may result in multiple invocations of the
26      * {@code initialValue} method in the current thread.
27      *
28      * @since 1.5
29      */
30      public void remove() {
31          ThreadLocalMap m = getMap(Thread.currentThread());
32          if (m != null)
33              m.remove(this);
34      }

 1 /**
 2      * Get the map associated with a ThreadLocal. Overridden in
 3      * InheritableThreadLocal.
 4      *
 5      * @param  t the current thread
 6      * @return the map
 7      */
 8     ThreadLocalMap getMap(Thread t) {
 9         return t.threadLocals;
10     }
11 
12     /**
13      * Create the map associated with a ThreadLocal. Overridden in
14      * InheritableThreadLocal.
15      *
16      * @param t the current thread
17      * @param firstValue value for the initial entry of the map
18      */
19     void createMap(Thread t, T firstValue) {
20         t.threadLocals = new ThreadLocalMap(this, firstValue);
21     }
22 
23     // Thread中的源码
24 
25     /* ThreadLocal values pertaining to this thread. This map is maintained
26      * by the ThreadLocal class. */
27     ThreadLocal.ThreadLocalMap threadLocals = null;
28 
29     /*
30      * InheritableThreadLocal values pertaining to this thread. This map is
31      * maintained by the InheritableThreadLocal class.
32      */
33     ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

 1 /**
 2          * Get the entry associated with key.  This method
 3          * itself handles only the fast path: a direct hit of existing
 4          * key. It otherwise relays to getEntryAfterMiss.  This is
 5          * designed to maximize performance for direct hits, in part
 6          * by making this method readily inlinable.
 7          *
 8          * @param  key the thread local object
 9          * @return the entry associated with key, or null if no such
10          */
11         private Entry getEntry(ThreadLocal<?> key) {
12             int i = key.threadLocalHashCode & (table.length - 1);
13             Entry e = table[i];
14             if (e != null && e.get() == key)
15                 return e;
16             else
17                 return getEntryAfterMiss(key, i, e);
18         }
19 
20         /**
21          * Version of getEntry method for use when key is not found in
22          * its direct hash slot.
23          *
24          * @param  key the thread local object
25          * @param  i the table index for key‘s hash code
26          * @param  e the entry at table[i]
27          * @return the entry associated with key, or null if no such
28          */
29         private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
30             Entry[] tab = table;
31             int len = tab.length;
32 
33             // 清理key为null的Entry
34             while (e != null) {
35                 ThreadLocal<?> k = e.get();
36                 if (k == key)
37                     return e;
38                 if (k == null)
39                     expungeStaleEntry(i);
40                 else
41                     i = nextIndex(i, len);
42                 e = tab[i];
43             }
44             return null;
45         }