ThreadLocal解析-优快云博客

Spring+Mybatis多数据源的实现：[url]http://donald-draper.iteye.com/blog/2326034[/url]
在上面一篇文章中我们在数据源切换的过程中用到过ThreadLocal，用ThreadLocal数据源名，主要是
保证每个线程的数据源相互独立，互不干扰。ThreadLocal声明的变量保证每个线程拥有一个独立的副本；以前的无论是Redis还是ActiveMQ系列篇中，凡是有数据源事务关联的我们都看到ThreadLocal，主要是保证每个线程的事务独立性，避免事务交叉。今天我们就来看看ThreadLocal源码。
//ThreadLocal

package java.lang;
import java.lang.ref.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * This class provides thread-local variables.  These variables differ from
 * their normal counterparts in that each thread that accesses one (via its
 * <tt>get</tt> or <tt>set</tt> method) has its own, independently initialized
 * copy of the variable.  <tt>ThreadLocal</tt> instances are typically private
 * static fields in classes that wish to associate state with a thread (e.g.,
 * a user ID or Transaction ID).
 *
 ThreadLocal提供线程本地变量。这些变量不同于线程一般用get和set方法获取的变量，
 它是一个独立的变量初始化拷贝。ThreadLocal实例是典型的私有静态访问fields，比如
 我们希望每个线程关联一个状态，如用户或事物的ID
 * <p>For example, the class below generates unique identifiers local to each
 * thread.
 * A thread's id is assigned the first time it invokes <tt>ThreadId.get()</tt>
 * and remains unchanged on subsequent calls.
 举个例子，ThreadId保证了每个线程用于一个本地唯一的标识。如果一个线程的id，在以第一次调用
ThreadId.get()方法时指定，接下来将不能改变
 * <pre>
 * import java.util.concurrent.atomic.AtomicInteger;
 *
 * public class ThreadId {
 *     // Atomic integer containing the next thread ID to be assigned
 *     private static final AtomicInteger nextId = new AtomicInteger(0);
 *
 *     // Thread local variable containing each thread's ID
 *     private static final ThreadLocal<Integer> threadId =
 *         new ThreadLocal<Integer>() {
 *         @Override 
           protected Integer initialValue() {
 *                 return nextId.getAndIncrement();
 *         }
 *     };
 *
 *     // Returns the current thread's unique ID, assigning it if necessary
 *     public static int get() {
 *         return threadId.get();
 *     }
 * }
 * </pre>
 * <p>Each thread holds an implicit reference to its copy of a thread-local
 * variable as long as the thread is alive and the <tt>ThreadLocal</tt>
 * instance is accessible; after a thread goes away, all of its copies of
 * thread-local instances are subject to garbage collection (unless other
 * references to these copies exist).
 *
 只要线程存活，每个线程将拥有一个隐式的线程本地变量ThreadLocal的副本，在一个线程结束
 之后所有的线程本地变量将会被垃圾回收器回收，除非有其他副本引用。
 * @author  Josh Bloch and Doug Lea
 * @since   1.2
 */
public class ThreadLocal<T> {
    /**
     * ThreadLocals rely on per-thread linear-probe hash maps attached
     * to each thread (Thread.threadLocals and
     * inheritableThreadLocals).  The ThreadLocal objects act as keys,
     * searched via threadLocalHashCode.  This is a custom hash code
     * (useful only within ThreadLocalMaps) that eliminates collisions
     * in the common case where consecutively constructed ThreadLocals
     * are used by the same threads, while remaining well-behaved in
     * less common cases.
     ThreadLocals依靠每个线程的哈希Map将线程本地变量（Thread.threadLocals and
     inheritableThreadLocals）保存在每个线程中。ThreadLocal作为Entry的Key我们
     可以通过threadLocalHashCode查找。这个哈希值只对ThreadLocalMaps有用，用于
     排除在相同的线程中构造ThreadLocals引起的冲突，
     */
    private final int threadLocalHashCode = nextHashCode();

    /**
     * The next hash code to be given out. Updated atomically. Starts at
     * zero.
     用于计算下一个哈希值
     */
    private static AtomicInteger nextHashCode =
        new AtomicInteger();

    /**
     * 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.
     //哈希值增长步长，计算ThreadLocal的ID
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Returns the next hash code.
     返回ThreadLocal的下一个hashCode，先get后add
     */
    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    /**
     * Creates a thread local variable.
     */
    public ThreadLocal() {
    }
}

我们一般用ThreadLocal为如下形式

/** 
  * 数据源上下文 
  * @author donald 
  * 
  */  
 public  class DataSourceContextHolder {  
     public final static String DATA_SOURCE_LOCAL = "dataSource";  
     public final static String DATA_SOURCE_SYNC = "syncDataSource";  
     //对数据源名，线程隔离  
     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();  

     public static void setDataSourceType(String dataSource) {    
         contextHolder.set(dataSource);    
     }        
     public static String getDataSourceType() {    
         return contextHolder.get();    
     }     
     public static void clearDataSourceType() {    
         contextHolder.remove();    
     }    
 }

ThreadLocal一般被声明为 private static final。
ThreadLocal主要要set，get和remove，3个主要方法。下面我们分别来看：
先看set方法；

/**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     设置当前线程本地变量的拷贝为特定的值。大多数的子类不需要重写此方法，
     只需要单独重写#initialValue设置线程本地变量值。
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
	//获取当前线程的ThreadLocalMap
        ThreadLocalMap map = getMap(t);
        if (map != null)
	    //如果不为null，则将TheadLocal和对应的值放入ThreadLocalMap
            map.set(this, value);
        else
	    //否则根据当前线程和对应的线程本地变量值创建ThreadLocalMap
            createMap(t, value);
    }

这个方法有3点要关注为：
1.

 Thread t = Thread.currentThread();
//获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);

if (map != null)
    //如果不为null，则将TheadLocal和对应的值放入ThreadLocalMap
    map.set(this, value);

else
    //否则根据当前线程和对应的线程本地变量值创建ThreadLocalMap
    createMap(t, value);

下面我们分别来看这几点，先看第3点:

else
    //否则根据当前线程和对应的线程本地变量值创建ThreadLocalMap
    createMap(t, value);

 /**
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     创建当前线程的ThreadLocalMap，并ThreadLocal和对应的value添加到ThreadLocalMap
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

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

上面这一段是线程的内部变量threadLocals，inheritableThreadLocals；
threadLocals保存线程本地变量，inheritableThreadLocals保存从父类继承的线程本地变量。在往下看之前我们来看一下ThreadLocalMap的定义：

/**
     * 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.
     ThreadLocalMap是用于维护线程本地变量的哈希Map。没够操作暴露给外部的类ThreadLocal。ThreadLocalMap是私有的内部类，允许在Thread中声明为fields。为了保证在大量长存活对象存在的Map的高效可利用性，我们用WeakReferences来保存key值。由于队列不在被引用，当table使用时，超时空间，可以保证那些stale（陈腐，即key为null）的Entry被移除。
     */
    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.
         Entry扩展了WeakReference，用于维护key的引用。如果可以为null，表示key不在
	 被引用，可以从哈希表中移除。这样的Entry，我们在以下代码中称谓stale entries，。
         */
        static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

        /**
         * The initial capacity -- MUST be a power of two.
	 初始化容量，必须为2的N次方
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
	 存放Entry的table，长度总是为2的n次方，如果需要重新扩容
         */
        private Entry[] table;

        /**
         * The number of entries in the table.
	 table中的Entry数。
         */
        private int size = 0;

        /**
         * The next size value at which to resize.
	 扩容因子
         */
        private int threshold; // Default to 0

        /**
         * Set the resize threshold to maintain at worst a 2/3 load factor.
	 设置扩容因子为扩容临界条件的2/3
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }
	 /**
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
	 构建一个ThreadLocalMap，并将Entry(firstKey, firstValue)放入到hashMap中
         */
        ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
	    //获取ThreadLocal的table索引
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
	    //设置扩容临界条件为初始化容量的2/3
            setThreshold(INITIAL_CAPACITY);
        }

}

回到set方法的几个关键点
1.

 Thread t = Thread.currentThread();
//获取当前线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);

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

if (map != null)
    //如果不为null，则将TheadLocal和对应的值放入ThreadLocalMap
    map.set(this, value);

 /**
  * Set the value associated with key.
  *设置线程本地变量的值
  * @param key the thread local object
  * @param value the value to be set
  */
 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;
     //定位线程本地变量在ThreadLocalMap的table中的索引
     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) {
	     //如果ThreadLocal已经存在，则更新对应的值
             e.value = value;
             return;
         }
         if (k == null) {
	     //如果ThreadLocal不存在，则替换ThreadLocal
             replaceStaleEntry(key, value, i);
             return;
         }
     }
     //索引上的Entry为null，则创建一个新Entry添加table中
     tab[i] = new Entry(key, value);
     int sz = ++size;
     //如果清除索引i之后table上stale Entry失败，且到达扩容条件，则扩容
     if (!cleanSomeSlots(i, sz) && sz >= threshold)
         rehash();
}

这里有节点要关注：
a.

nextIndex(i, len)

if (k == null) {
    //如果ThreadLocal不存在，则替换ThreadLocal
    replaceStaleEntry(key, value, i);
    return;
}

//如果清除索引i之后table上stale Entry失败，且到达扩容条件，则扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();

下面分别来看这几点：
a.

nextIndex(i, len)

/**
  * Increment i modulo len.
  //获取索引i的下一个table索引
  */
 private static int nextIndex(int i, int len) {
     return ((i + 1 < len) ? i + 1 : 0);
 }

if (k == null) {
    //如果ThreadLocal不存在，则替换ThreadLocal
    replaceStaleEntry(key, value, i);
    return;
}

private void replaceStaleEntry(ThreadLocal key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    // Back up to check for prior stale entry in current run.
    // We clean out whole runs at a time to avoid continual
    // incremental rehashing due to garbage collector freeing
    // up refs in bunches (i.e., whenever the collector runs).
    int slotToExpunge = staleSlot;
    //向索引i之前遍历，找到第一个Entry的key为null的
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
	    //如果Entry对应的key，及ThreadLocal为null，记录索引
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    //向staleSlot之后遍历
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // The newly stale slot, or any other stale slot
        // encountered above it, can then be sent to expungeStaleEntry
        // to remove or rehash all of the other entries in run.
        if (k == key) {
	    //如果key相等，则交换当前的Entry和之前Entry的key为null的stale entry，
            //即将stale Entry往table的后面移
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
            // Start expunge at preceding stale entry if it exists
	    //如果staleSlot之前没有stale Entry，则slotToExpune为i
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
	    //清除
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
	//如果向后遍历的Entry的key为null，且staleSlot前面无stale Entry，则
	//需要清除的Entry为当前Entry
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }
   如果staleSlot之后的Entry为null，则直接将新放入的Entry添加到table的staleSlot位置上
    // If key not found, put new entry in stale slot
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);
    // If there are any other stale entries in run, expunge them
    //存在其他的stale Entry，则清除
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

从方法来看replaceStaleEntry所有做的工作，从当前Stale Entry的位置staleSlot，
遍历找到最前面的Stale Entry的位置slotToExpunge，并向后遍历Entry如果有Key相等的，
则与staleSlot交换Entry，即将stale Entry往table后面移。如果Stale Entry的位置staleSlot前面没有stale Entry，则slotToExpunge为当前位置（staleSlot后第一个与key相等的），移除当前位置Entry，并重新冲突的Entry。如果staleSlot的Entry为stale状态，则移除。
先来看一下向前移动位置：

 /**
  * Decrement i modulo len.
  */
 private static int prevIndex(int i, int len) {
     return ((i - 1 >= 0) ? i - 1 : len - 1);
 }

再来看移除stale Entry,解决冲突的Entry。

/**
  * 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
     //移除staleSlot位置的Entry
     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 {
	    //遍历staleSlot之后的Entry，如果为stale，则移除，否则重新hash
             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;
 }

//如果清除索引i之后table上stale Entry失败，且到达扩容条件，则扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
    rehash();

//移除i位置之后的的stale Entry
private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    //向后遍历table
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
	    //Entry为stale，则移除
            removed = true;
	    //移除i位置上的stale，并解决冲突
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

来看重hash

/**
  * Re-pack and/or re-size the table. First scan the entire
  * table removing stale entries. If this doesn't sufficiently
  * shrink the size of the table, double the table size.
  */
 private void rehash() {
     //移除所有stale Entry
     expungeStaleEntries();
     // Use lower threshold for doubling to avoid hysteresis
     if (size >= threshold - threshold / 4)
         resize();
}
 /**
  * Expunge all stale entries in the table.
  移除所有stale Entry
  */
 private void expungeStaleEntries() {
     Entry[] tab = table;
     int len = tab.length;
     for (int j = 0; j < len; j++) {
         Entry e = tab[j];
         if (e != null && e.get() == null)
             expungeStaleEntry(j);
     }
 }
/**
 * Double the capacity of the table.
  扩容，这个有了前面的基础，这里就容易了
 */
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal k = e.get();
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    setThreshold(newLen);
    size = count;
    table = newTab;
}

至此ThreadLocal的set方法讲解完毕，小节一下:
每个线程拥有一个线程本地变量ThreadLocalMap-threadLocals和一个可继承的ThreadLocalMap-inheritableThreadLocals。每个ThreadLocal关联一个threadLocalHashCode，在设值ThreadLocal时，获取当前线程的线程本地变量ThreadLocalMap-threadLocals，如果为空，则初始化当前线程的threadLocals，
即创建一个ThreadLocalMap，并将TheadLocal的threadLocalHashCode与value的映射Entry添加到threadLocals中，如果当前线程的threadLocals不为null，则添加TheadLocal的threadLocalHashCode与value的映射Entry。
再看看get方法：

* 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.
   *
   返回当前线程的线程本地变量的值。如果当前线程的线程本地变量Map为空，则初始化线程本地变量值。
   * @return the current thread's value of this thread-local
   */
  public T get() {
      Thread t = Thread.currentThread();
      ThreadLocalMap map = getMap(t);
      if (map != null) {
          //如果当线程的线程本地变量Map不为null，直接从Map中获取
          ThreadLocalMap.Entry e = map.getEntry(this);
          if (e != null)
              return (T)e.value;
      }
      //否则，初始化线程本地变量值
      return setInitialValue();
  }

//先看从Map获取值
//ThreadLocalMap

private Entry getEntry(ThreadLocal key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
         //找到，则返回对应的Entry
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}
  * Version of getEntry method for use when key is not found in
  * its direct hash slot.
  *
  * @param  key the thread local object
  * @param  i the table index for key's hash code
  * @param  e the entry at table[i]
  * @return the entry associated with key, or null if no such
  */
 private Entry getEntryAfterMiss(ThreadLocal key, int i, Entry e) {
     Entry[] tab = table;
     int len = tab.length;
    //遍历i位置之后的Entry，找到key对应的Entry，则返回，如果Entry为stale，则移除
     while (e != null) {
         ThreadLocal k = e.get();
         if (k == key)
             return e;
         if (k == null)
             expungeStaleEntry(i);
         else
             i = nextIndex(i, len);
         e = tab[i];
     }
     return null;
 }

再来看初始化TheadLocal

/**
     * 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;
    }
   //待子类扩展
   protected T initialValue() {
        return null;
    }

从上面来看get方法，首先获取当前线程的线程本地变量Map-threadLocals，如果不为空，则从Map中，获取ThreadLocal的threadLocalHashCode对应Entry，返回对应的值，如果threadLocals为null，首先初始化ThreadLocal的值，然后重新检查
threadLocals是否为null，后面的与set的方法相同，就不说了。
再来看remove方法：

public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
	     //如果当前线程的threadLocals不为null，直接从threadLocals中移除ThreadLocal
             m.remove(this);
 }

//ThreadLocalMap

/**
   * Remove the entry for key.
   */
  private void remove(ThreadLocal key) {
      Entry[] tab = table;
      int len = tab.length;
      int i = key.threadLocalHashCode & (len-1);
      //遍历ThreadLocal位置之后的Entry，如果key相等，则移除Entry，并清除参考
      for (Entry e = tab[i];
           e != null;
           e = tab[i = nextIndex(i, len)]) 
          if (e.get() == key) {
              e.clear();
              expungeStaleEntry(i);
              return;
          }
      }
  }

我们来看参考清除

e.clear();

//Reference
/**
 * Clears this reference object.  Invoking this method will not cause this
 * object to be enqueued.
 *
 * <p> This method is invoked only by Java code; when the garbage collector
 * clears references it does so directly, without invoking this method.
 */
public void clear() {
    this.referent = null;
}

移除操作，主要是从当前线程的threadLocals移除对应的TheadLocal，并清除TheadLocal的引用。

再看创建可继承的线程本地变量方法：

/**
     * Factory method to create map of inherited thread locals.
     * Designed to be called only from Thread constructor.
     *
     * @param  parentMap the map associated with parent thread
     * @return a map containing the parent's inheritable bindings
     */
    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

//ThreadLocalMap

/**
 * Construct a new map including all Inheritable ThreadLocals
 * from given parent map. Called only by createInheritedMap.
 *
 将父线程中的线程本地变量，放到子线程中
 * @param parentMap the map associated with parent thread.
 */
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];
    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            ThreadLocal key = e.get();
            if (key != null) {
	       //获取Thread子线程的值
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}

 /**
  * Method childValue is visibly defined in subclass
  * InheritableThreadLocal, but is internally defined here for the
  * sake of providing createInheritedMap factory method without
  * needing to subclass the map class in InheritableThreadLocal.
  * This technique is preferable to the alternative of embedding
  * instanceof tests in methods.
  待子类扩展，根据父线程的值，返回子线程的值
  */
 T childValue(T parentValue) {
     throw new UnsupportedOperationException();
 }

总结：
[color=blue]每个线程拥有一个线程本地变量ThreadLocalMap-threadLocals和一个可继承的ThreadLocalMap-inheritableThreadLocals。每个ThreadLocal关联一个threadLocalHashCode，在set设值ThreadLocal时，获取当前线程的线程本地变量ThreadLocalMap-threadLocals，如果为空，则初始化当前线程的threadLocals，
即创建一个ThreadLocalMap，并将TheadLocal的threadLocalHashCode与value的映射Entry添加到threadLocals中，如果当前线程的threadLocals不为null，则添加TheadLocal的threadLocalHashCode与value的映射Entry。get方法，首先获取当前线程的线程本地变量Map-threadLocals，如果不为空，则从Map中，获取ThreadLocal的threadLocalHashCode对应Entry，返回对应的值，如果threadLocals为null，首先初始化ThreadLocal的值，然后重新检查threadLocals是否为null，后面的与set的方法相同，就不说了。移除操作，主要是从当前线程的threadLocals移除对应的TheadLocal，并清除TheadLocal的引用。[/color]

最后我们再来看一下可继承的线程本地变量InheritableThreadLocal
//InheritableThreadLocal

package java.lang;
import java.lang.ref.*;

/**
 * This class extends <tt>ThreadLocal</tt> to provide inheritance of values
 * from parent thread to child thread: when a child thread is created, the
 * child receives initial values for all inheritable thread-local variables
 * for which the parent has values.  Normally the child's values will be
 * identical to the parent's; however, the child's value can be made an
 * arbitrary function of the parent's by overriding the <tt>childValue</tt>
 * method in this class.
 *
InheritableThreadLocal继承了ThreadLocal，提供了子线程继承父线程本地变量的实现；
当子线程被创建，子线程将会拥有父线程所有可继承的线程本地变量。一般情况子线程的本地
变量值与父线程相同；如果子线程重写的父线程的childValue，将不能保证。
 * <p>Inheritable thread-local variables are used in preference to
 * ordinary thread-local variables when the per-thread-attribute being
 * maintained in the variable (e.g., User ID, Transaction ID) must be
 * automatically transmitted to any child threads that are created.
 当每个线程的属性保存在一个变量中如用户ID和事务ID，如果是可继承的线程本地变量
 必须自动的传给所有创建的子线程，可继承的线程本地变量优先于一般的线程变量被使用。
 * @author  Josh Bloch and Doug Lea
 * @see     ThreadLocal
 * @since   1.2
 */

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
    /**
     * Computes the child's initial value for this inheritable thread-local
     * variable as a function of the parent's value at the time the child
     * thread is created.  This method is called from within the parent
     * thread before the child is started.
     在子线程创建时，初始化子线程从父线程继承的线程本地变量。这个方法在子线程启动之前，
     父线程调用。跟父线程的本地变量值，返回子线程的线程本地变量值，InheritableThreadLocal为
     直接继承父类的值
     * <p>
     * This method merely returns its input argument, and should be overridden
     * if a different behavior is desired.
     *
     * @param parentValue the parent thread's value
     * @return the child thread's initial value
     */
    protected T childValue(T parentValue) {
        return parentValue;
    }

    /**
     * Get the map associated with a ThreadLocal.
     *
     获取线程关联ThreadLocal
     * @param t the current thread
     */
    ThreadLocalMap getMap(Thread t) {
       return t.inheritableThreadLocals;
    }

    /**
     * Create the map associated with a ThreadLocal.
     *
     创建一个线程关联ThreadLocal的Map
     * @param t the current thread
     * @param firstValue value for the initial entry of the table.
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
    }
}

实例:

public class ParentThread extends Thread {
   void run (){
      ChildThread cThread = new ChildThread()
      cThread.inheritableThreadLocals = ThreadLocalMap.createInheritedMap(this.inheritableThreadLocals);
   }
}

public class ChildThread extends Thread {
   void run (){
      ...
   }
}

//WeakReference


package java.lang.ref;


/**
 * Weak reference objects, which do not prevent their referents from being
 * made finalizable, finalized, and then reclaimed.  Weak references are most
 * often used to implement canonicalizing mappings.
 *
 * <p> Suppose that the garbage collector determines at a certain point in time
 * that an object is <a href="package-summary.html#reachability">weakly
 * reachable</a>.  At that time it will atomically clear all weak references to
 * that object and all weak references to any other weakly-reachable objects
 * from which that object is reachable through a chain of strong and soft
 * references.  At the same time it will declare all of the formerly
 * weakly-reachable objects to be finalizable.  At the same time or at some
 * later time it will enqueue those newly-cleared weak references that are
 * registered with reference queues.
 *
 * @author   Mark Reinhold
 * @since    1.2
 */

public class WeakReference<T> extends Reference<T> {

    /**
     * Creates a new weak reference that refers to the given object.  The new
     * reference is not registered with any queue.
     *
     * @param referent object the new weak reference will refer to
     */
    public WeakReference(T referent) {
        super(referent);
    }

    /**
     * Creates a new weak reference that refers to the given object and is
     * registered with the given queue.
     *
     * @param referent object the new weak reference will refer to
     * @param q the queue with which the reference is to be registered,
     *          or <tt>null</tt> if registration is not required
     */
    public WeakReference(T referent, ReferenceQueue<? super T> q) {
        super(referent, q);
    }

}