深入解析ThreadLocal

public T get() { }
public void set(T value) { }
public void remove() { }
protected T initialValue() { }

 /**
 * Returns the value in the current thread's copy of this
 * thread-local variable. If the variable has no value for the
 * current thread, it is first initialized to the value returned
 * by an invocation of the {@link #initialValue} method.
 *
 * @return the current thread's value of this thread-local
 */
 public T get() {
 Thread t = Thread.currentThread();
 ThreadLocalMap map = getMap(t);
 if (map != null) {
 ThreadLocalMap.Entry e = map.getEntry(this);
 if (e != null) {
 @SuppressWarnings("unchecked")
 T result = (T)e.value;
 return result;
 }
 }
 return setInitialValue();
 }

 /**
 * Get the map associated with a ThreadLocal. Overridden in
 * InheritableThreadLocal.
 *
 * @param t the current thread
 * @return the map
 */
 ThreadLocalMap getMap(Thread t) {
 return t.threadLocals;
 }

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

 /**
 * ThreadLocalMap is a customized hash map suitable only for
 * maintaining thread local values. No operations are exported
 * outside of the ThreadLocal class. The class is package private to
 * allow declaration of fields in class Thread. To help deal with
 * very large and long-lived usages, the hash table entries use
 * WeakReferences for keys. However, since reference queues are not
 * used, stale entries are guaranteed to be removed only when
 * the table starts running out of space.
 */
 static class ThreadLocalMap {
 /**
 * The entries in this hash map extend WeakReference, using
 * its main ref field as the key (which is always a
 * ThreadLocal object). Note that null keys (i.e. entry.get()
 * == null) mean that the key is no longer referenced, so the
 * entry can be expunged from table. Such entries are referred to
 * as "stale entries" in the code that follows.
 */
 static class Entry extends WeakReference<ThreadLocal<?>> {
 /** The value associated with this ThreadLocal. */
 Object value;
 Entry(ThreadLocal<?> k, Object v) {
 super(k);
 value = v;
 }
 }

 /**
 * Variant of set() to establish initialValue. Used instead
 * of set() in case user has overridden the set() method.
 *
 * @return the initial value
 */
 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;
 }

 /**
 * 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);
 }

至此,我们可以明白ThreadLocal是如何为每个线程创建变量的副本的:
首先,每个线程Thread内部有一个Thread.ThreadLocalMap类型的成员变量threadlocals,这个threadlocals就是用来存储实际的变量副本的,键值为当前ThreadLocal变量,value为变量副本(即T类型的变量)。
初始时,在Thread里面,threadlocals为空,当通过ThreadLocal变量调用get()方法或者set()方法,就会对Thread类中的threadlocals进行初始化,并且以当前ThreadLocal为键值,以ThreadLocal要保存的副本变量为value,存到threadlocals中。
然后,在当前线程里面,如果要使用副本变量,就可以通过get方法在threadlocals里面查找。

总结
1. 通过ThreadLocal创建的副本是存储在每个线程自己的threadlocals中的;
2. 为何threadlocals的类型ThreadLocalMap的键值为ThreadLocal对象,因为每个线程中可以有多个ThreadLocal变量,例如ThreadLocal,ThreadLocal;
3. 在进行get之前,必须先set,否则会报空指针异常;如果想在调用get之前不调用set就能正常访问的话,必须重写initialValue()方法。