ThreadLocal知识总结

一、ThreadLocalMap是ThreadLocal的内部类、Thread持有ThreadLocalMap的引用

Entry类继承了WeakReference<ThreadLocal<?>>，即每个Entry对象都有一个ThreadLocal的弱引用（作为key），这是为了防止内存泄露。

key变为一个不可达的对象(null)，这个Entry就可以被GC了。

  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;
             }
         }

1.ThreadLocalMap成员变量分析，放入第一个元素时，才生成Entry数组实例

 /*** The initial capacity -- MUST be a power of two.
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * The number of entries in the table.
         */
        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.
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        /**
         * Increment i modulo len.
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

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

        /**
         * 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(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

ThreadLocalMap构造函数的第一个参数就是该ThreadLocal实例(this)，第二个参数就是要保存的线程本地变量。

构造函数首先创建一个长度为16的Entry数组，然后计算出firstKey对应的哈希值，然后存储到table中，并设置size和threshold。

注意一个细节，计算hash的时候里面采用了hashCode & (size - 1)的算法，这相当于取模运算hashCode % size的一个更高效的实现（和

HashMap中的思路相同）。正是因为这种算法，我们要求size必须是2的指数，因为这可以使得hash发生冲突的次数减小。

2、Thread持有两个ThreadLocalMap的引用，一个用于保存当前线程的局部变量，另一个保存父线程的局部变量

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

二、ThreadLocal的set()方法

    public void set(T value) {
         Thread t = Thread.currentThread();
         ThreadLocalMap map = getMap(t);
         if (map != null)
             map.set(this, value);                        //以ThreadLocal为键
         else
             createMap(t, value);
     }
    void createMap(Thread t, T firstValue) {
         t.threadLocals = new ThreadLocalMap(this, firstValue);     //以ThreadLocal为键
 }

ThreadLocal的get()方法

    public T get() {
         Thread t = Thread.currentThread();  //得到当前线程
         ThreadLocalMap map = getMap(t);     //得到当前线程相关的ThreadLocalMap
         if (map != null) {
             ThreadLocalMap.Entry e = map.getEntry(this);
             if (e != null)
                 return (T)e.value;
         }
         return setInitialValue();
     }

    ThreadLocalMap getMap(Thread t) {
         return t.threadLocals;
     }

ThreadLocal在Hibernate中的应用

     private static final ThreadLocal threadSession = new ThreadLocal();

     public static Session getSession() throws InfrastructureException {
         Session s = (Session) threadSession.get();
         try {
             if (s == null) {
                 s = getSessionFactory().openSession();
                 threadSession.set(s);
             }
         } catch (HibernateException ex) {
             throw new InfrastructureException(ex);
         }
         return s;
     }

三、总结

我们在多线程的开发中，经常会考虑到的策略是对一些需要公开访问的属性通过设置同步的方式来访问。这样每次能保证只有一个线程访问它，不会有冲突。

但是这样做的结果会使得性能和对高并发的支持不够。在某些情况下，如果我们不一定非要对一个变量共享不可，而是给每个线程一个这样的资源副本，让他们可

以独立都各自跑各自的，这样不是可以大幅度的提高并行度和性能了吗？

还有的情况是有的数据本身不是线程安全的，或者说它只能被一个线程使用，不能被其他线程同时使用。如果等一个线程使用完了再给另外一个线程使用就

根本不现实。这样的情况下，我们也可以考虑用ThreadLocal。一个典型的情况就是我们连接数据库的时候通常会用到连接池。而对数据库的连接不能有多个线程

共享访问。这个时候就需要使用ThreadLocal了。

 private static ThreadLocal<Connection> connectionHolder =
     new ThreadLocal<Connection>() {
         public Connection initialValue() {
             return DriverManager.getConnection(DB_URL);
         }
     };

 pubic static Connection getConnection() {
     return connectionHolder.get();
 }

四、ThreadLocal使用总结

ThreadLocal对象建议使用static修饰。这个变量是针对一个线程内所有操作共有的，

所以设置为静态变量，所有此类实例共享此静态变量 ，也就是说在类第一次被使用时装载，只分配一块存储空间

ThreadLocal instances are typically private static fields in classes that wish to associate state with a thread

(e.g., a user ID or Transaction ID).

Each thread holds an implicit reference to its copy of a thread-local variable as long as the thread is alive and the ThreadLocal

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).

参考：

深入理解 Java 之 ThreadLocal 工作原理