ThreadLocal学习

1、简介：

类ThreadLocal<T>，为变量提供了线程本地化副本。对于用ThreadLocal维护的变量，当前线程中的副本不同于它在其他线程中的副本，每个线程通过ThreadLocal提供的get、set等方法来独立维护自己的变量副本。当多线程环境中的变量使用ThreadLocal维护时，ThreadLocal为每个使用该变量的线程分配一个独立的变量副本。

ThreadLocal实例在类中通常作为静态私有化类变量。

2、ThreadLocal接口：

public T get(); //返回被维护变量的变量的线程本地化的副本值
public void set(T value); //将当前线程中维护的本地化副本值设置为value
public void remove(); //移除当前线程中被维护变量的值

protected T initialValue(); //提供线程本地化对象的初始值

3、适用性：

ThreadLocal适用于为每个线程都提供一个固定的初始状态的情形，每个线程使用自己的本地化对象来完成自己的操作。

4、Demo：

对非线程安全对象的改造:

     public class TopicDao{
          //一个非线程安全的变量
          private Connection conn;

          public void addTopic(){
              conn = DriverManager.getConnection();

            //在多线程环境中使用非线程安全变量
            Statement stat = conn.createStatement();
            
          }
     }

在使用JDBC来操作数据库时，Connection对象提供了所连接的数据库的表、支持的SQL语句等信息，但是Connection本身并不是一个线程安全变量，用于多线程环境中可能会出现问题。

改造： 使用ThreadLocal来为每个线程维护一个conn变量的线程本地化副本。

     public class TopicDao{
          //使用ThreadLocal来保存Connection变量
          private static ThreadLocal<Connection> connThreadLocal = new ThreadLocal<Connection>();
          public static Connection getConnection(){
               //如果connThreadLocal没有本线程对应的Connection，创建一个新的Connection，
               //并将其保存到线程本地变量中
               if(connThreadLocal.get() == null ){
                    Connection conn = ConnectionManager.getConnection();
                    connThreadLocal.set(conn);
                    return conn;
               }else{
                    //直接返回线程本地变量
                    return connThreadLocal.get();
               }
          }

          public void addTopic(){
               //从ThreadLocal中获取线程对象
               Statement stat = getConnection().createStatement();
          }
     }

ThreadLocal使用方式：

由例子中也可看出，ThreadLocal实例通常作为类的私有静态成员，并且提供一个静态方法来返回ThreadLocal所维护的线程本地化对象（该例中未conn）的值，同时在该静态方法中为每个线程提供该线程本地化对象的初始值。

5、ThreadLocal.java源文件：

    /**
    * ThreadLocal内部包含一个用数组实现的哈希表，用来存储对应到每个线程的局部对象的值
    * 其中，ThreadLocal对象担当key，实际通过threadLocalHashCode值来进行检索
    */
       public class ThreadLocal<T> {
           /**
           * 存储用于确定哈希表的键值
           */
           private final int threadLocalHashCode = nextHashCode();

           /** 
           * 返回在当前线程中的线程局部对象的值， 
           * 若线程局部对象对于当前线程没有值，则被初始化微 initialValue方法的返回值 
        */ 
        public T get() { 
              Thread t = Thread.currentThread(); 
              ThreadLocalMap map = getMap(t); 
              if (map != null) { 
                  ThreadLocalMap.Entry e = map.getEntry(this); 
                  if (e != null) 
                      return (T)e.value; 
              } 
  
                  return setInitialValue(); 
          } 
  
          /** 
         * 获取当前线程对应的ThreadLocalMap对象
         * 若存在，则将当前线程与T类型变量value按照名值对的方式放置到ThreadLocalMap中；
         * 若不存在，则创建当前ThreadLocalMap对象，并放入
          */ 
          public void set(T value) { 
              Thread t = Thread.currentThread(); 
              ThreadLocalMap map = getMap(t); 
              if (map != null) 
              //以当前线程对象为key，设置当前局部对象的值
              map.set(this, value); 
              else 
              createMap(t, value); 
          } 
  
          /** 
          * 移除当前线程中所保存的本地化对象的值
          */ 
          public void remove() { 
              ThreadLocalMap m = getMap(Thread.currentThread()); 
              if (m != null) 
                  //从ThreadLocalMap中移除对象
                  m.remove(this); 
          } 
  
          /** 
          * 返回当前线程关联的ThreadLocalMap对象
          * 查看Thread源码可知，每个Thread都含有ThreadLocal.ThreadLocalMap类型的threadLocals变量
          */ 
          ThreadLocalMap getMap(Thread t) { 
          return t.threadLocals; 
          } 
  
          /** 
          * 创建当前线程关联的ThreadLocalMap对象
          */
          void createMap(Thread t, T firstValue) { 
          t.threadLocals = new ThreadLocalMap(this, firstValue);
          } 
  
         /**
         * ThreadLocalMap是一个定制的只能用来存储线程局部对象的哈希映射表
         *
         * 使用数组来作为哈希表存储结构
        *
         * 其中数组中元素类型为Entry，Entry为指向ThreadLocal的弱引用的子类，并且含有Object变量来维护与当前ThreadLocal对象关联的变量值
         *
         */
        static class ThreadLocalMap { 
              
            static class Entry extends WeakReference<ThreadLocal> { 
                /** 
                * 维护与当前ThreadLocal相关联的变量值 
                */ 
                 Object value; 
     
                 Entry(ThreadLocal k, Object v) { 
                  super(k); 
                  value = v; 
                 } 
            } 
     
            //哈希表的初始大小 
            private static final int INITIAL_CAPACITY = 16; 
     
             /** 
             * 哈希表存储的数组
             * 
             * 其中数组中元素类型为Entry，Entry为指向ThreadLocal的弱引用的子类，并且含有Object变量来维护与当前ThreadLocal对象关联的变量值
             */ 
             private Entry[] table; 
     
             /**
             * ThreadLocalMap使用延迟初始化，当我们需要向ThreadLocalMap中放元素时，才会初始化它 
             */
             ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { 
                 table = new Entry[INITIAL_CAPACITY]; 
                 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); //产生哈希值
                 table[i] = new Entry(firstKey, firstValue); //初始时，使用ThreadLocal.threadLocalHashCode作为哈希表的哈希值 size = 1; 
     
                 //设定ThreadLocalMap中元素个数 
                 setThreshold(INITIAL_CAPACITY); 
             } 
     
            /** 
            * 设置于当前key所关联的线程本地化对象的值
            *
            * 涉及到哈希表的冲突处理
            */ 
             private void set(ThreadLocal key, Object value) { 
                 Entry[] tab = table; 
                 int len = tab.length; 
                 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) { 
                         e.value = value; 
                         return; 
                     } 
     
                     if (k == null) { 
                         replaceStaleEntry(key, value, i); 
                         return;
                     } 
                 } 
     
                 tab[i] = new Entry(key, value); 
                 int sz = ++size; 
                 if (!cleanSomeSlots(i, sz) && sz >= threshold) 
                     rehash(); 
             } 
     
             /** 
             * 删除ThreadLocal对应的线程本地化对象的值
             */ 
             private void remove(ThreadLocal key) { 
                Entry[] tab = table; 
                int len = tab.length; 
                int i = key.threadLocalHashCode & (len-1); 
                for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { 
                      if (e.get() == key) { 
                        e.clear(); 
                        expungeStaleEntry(i); 
                        return; 
                    } 
                } 
            } 
        }
    }

根据ThreadLocal.java中列出的源码，可以走一遍ThreadLocal是如何进行set、get、remove操作的，可以加深对ThreadLocal对象的理解和其内部工作机制。

注：查看Thread源码可知，每个Thread类中都含有ThreadLocal.ThreadLocalMap类型的threadLocals变量（初始值为null）。