正确理解ThreadLocal

首先，ThreadLocal 不是用来解决共享对象的多线程访问问题的，一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。各个线程中访问的是不同的对象。

另外，说ThreadLocal使得各线程能够保持各自独立的一个对象，并不是通过ThreadLocal.set()来实现的，而是通过每个线程中的new 对象 的操作来创建的对象，每个线程创建一个，不是什么对象的拷贝或副本。通过 ThreadLocal.set()将这个新创建的对象的引用保存到各线程的自己的一个map中，每个线程都有这样一个map，执行 ThreadLocal.get()时，各线程从自己的map中取出放进去的对象，因此取出来的是各自自己线程中的对象，ThreadLocal实例是作为map的key来使用的。

如果ThreadLocal.set()进去的东西本来就是多个线程共享的同一个对象，那么多个线程的ThreadLocal.get()取得的还是这个共享对象本身，还是有并发访问问题。

下面来看一个hibernate中典型的ThreadLocal的应用：
Java 代码

   1. private static final ThreadLocal threadSession = new ThreadLocal(); 
   2.  
   3. public static Session getSession() throws InfrastructureException { 
   4.     Session s = (Session) threadSession.get(); 
   5.     try { 
   6.         if (s == null) { 
   7.             s = getSessionFactory().openSession(); 
   8.             threadSession.set(s); 
   9.         } 
  10.     } catch (HibernateException ex) { 
  11.         throw new InfrastructureException(ex); 
  12.     } 
  13.     return s; 
  14. } 

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


可以看到在getSession()方法中，首先判断当前线程中有没有放进去session，如果还没有，那么通过 sessionFactory().openSession()来创建一个session，再将session set到线程中，实际是放到当前线程的ThreadLocalMap这个map中，这时，对于这个session的唯一引用就是当前线程中的那个 ThreadLocalMap（下面会讲到），而threadSession作为这个值的key，要取得这个session可以通过 threadSession.get()来得到，里面执行的操作实际是先取得当前线程中的ThreadLocalMap，然后将 threadSession作为key将对应的值取出。这个session相当于线程的私有变量，而不是public的。
显然，其他线程中是取不到这个session的，他们也只能取到自己的ThreadLocalMap中的东西。要是session是多个线程共享使用的，那还不乱套了。
试想如果不用ThreadLocal怎么来实现呢？可能就要在action中创建session，然后把session一个个传到service 和dao中，这可够麻烦的。或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中，应该也行，这也是一般人的想法，但事实上，ThreadLocal的实现刚好相反，它是在每个线程中有一个map，而将ThreadLocal实例作为key，这样每个map中的项数很少，而且当线程销毁时相应的东西也一起销毁了，不知道除了这些还有什么其他的好处。

总之，ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点：
1。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

当然如果要把本来线程共享的对象通过ThreadLocal.set()放到线程中也可以，可以实现避免参数传递的访问方式，但是要注意 get()到的是那同一个共享对象，并发访问问题要靠其他手段来解决。但一般来说线程共享的对象通过设置为某类的静态变量就可以实现方便的访问了，似乎没必要放到线程中。

ThreadLocal的应用场合，我觉得最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。

下面来看看ThreadLocal的实现原理（jdk1.5源码）
Java 代码

   1. public class ThreadLocal<T> { 
   2.     /**
   3.      * ThreadLocals rely on per-thread hash maps attached to each thread
   4.      * (Thread.threadLocals and inheritableThreadLocals).  The ThreadLocal
   5.      * objects act as keys, searched via threadLocalHashCode.  This is a
   6.      * custom hash code (useful only within ThreadLocalMaps) that eliminates
   7.      * collisions in the common case where consecutively constructed
   8.      * ThreadLocals are used by the same threads, while remaining well-behaved
   9.      * in less common cases.
  10.      */ 
  11.     private final int threadLocalHashCode = nextHashCode(); 
  12.  
  13.     /**
  14.      * The next hash code to be given out. Accessed only by like-named method.
  15.      */ 
  16.     private static int nextHashCode = 0; 
  17.  
  18.     /**
  19.      * The difference between successively generated hash codes - turns
  20.      * implicit sequential thread-local IDs into near-optimally spread
  21.      * multiplicative hash values for power-of-two-sized tables.
  22.      */ 
  23.     private static final int HASH_INCREMENT = 0x61c88647; 
  24.  
  25.     /**
  26.      * Compute the next hash code. The static synchronization used here
  27.      * should not be a performance bottleneck. When ThreadLocals are
  28.      * generated in different threads at a fast enough rate to regularly
  29.      * contend on this lock, memory contention is by far a more serious
  30.      * problem than lock contention.
  31.      */ 
  32.     private static synchronized int nextHashCode() { 
  33.         int h = nextHashCode; 
  34.         nextHashCode = h + HASH_INCREMENT; 
  35.         return h; 
  36.     } 
  37.  
  38.     /**
  39.      * Creates a thread local variable.
  40.      */ 
  41.     public ThreadLocal() { 
  42.     } 
  43.  
  44.     /**
  45.      * Returns the value in the current thread's copy of this thread-local
  46.      * variable.  Creates and initializes the copy if this is the first time
  47.      * the thread has called this method.
  48.      *
  49.      * @return the current thread's value of this thread-local
  50.      */ 
  51.     public T get() { 
  52.         Thread t = Thread.currentThread(); 
  53.         ThreadLocalMap map = getMap(t); 
  54.         if (map != null) 
  55.             return (T)map.get(this); 
  56.  
  57.         // Maps are constructed lazily.  if the map for this thread 
  58.         // doesn't exist, create it, with this ThreadLocal and its 
  59.         // initial value as its only entry. 
  60.         T value = initialValue(); 
  61.         createMap(t, value); 
  62.         return value; 
  63.     } 
  64.  
  65.     /**
  66.      * Sets the current thread's copy of this thread-local variable
  67.      * to the specified value.  Many applications will have no need for
  68.      * this functionality, relying solely on the {@link #initialValue}
  69.      * method to set the values of thread-locals.
  70.      *
  71.      * @param value the value to be stored in the current threads' copy of
  72.      *        this thread-local.
  73.      */ 
  74.     public void set(T value) { 
  75.         Thread t = Thread.currentThread(); 
  76.         ThreadLocalMap map = getMap(t); 
  77.         if (map != null) 
  78.             map.set(this, value); 
  79.         else 
  80.             createMap(t, value); 
  81.     } 
  82.  
  83.     /**
  84.      * Get the map associated with a ThreadLocal. Overridden in
  85.      * InheritableThreadLocal.
  86.      *
  87.      * @param  t the current thread
  88.      * @return the map
  89.      */ 
  90.     ThreadLocalMap getMap(Thread t) { 
  91.         return t.threadLocals; 
  92.     } 
  93.  
  94.     /**
  95.      * Create the map associated with a ThreadLocal. Overridden in
  96.      * InheritableThreadLocal.
  97.      *
  98.      * @param t the current thread
  99.      * @param firstValue value for the initial entry of the map
100.      * @param map the map to store.
101.      */ 
102.     void createMap(Thread t, T firstValue) { 
103.         t.threadLocals = new ThreadLocalMap(this, firstValue); 
104.     } 
105.  
106.     ....... 
107.  
108.     /**
109.      * ThreadLocalMap is a customized hash map suitable only for
110.      * maintaining thread local values. No operations are exported
111.      * outside of the ThreadLocal class. The class is package private to
112.      * allow declaration of fields in class Thread.  To help deal with
113.      * very large and long-lived usages, the hash table entries use
114.      * WeakReferences for keys. However, since reference queues are not
115.      * used, stale entries are guaranteed to be removed only when
116.      * the table starts running out of space.
117.      */ 
118.     static class ThreadLocalMap { 
119.  
120.     ........ 
121.  
122.     } 
123.  
124. } 

public class ThreadLocal<T> {
    /**
     * ThreadLocals rely on per-thread 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.
     */
    private final int threadLocalHashCode = nextHashCode();

    /**
     * The next hash code to be given out. Accessed only by like-named method.
     */
    private static int nextHashCode = 0;

    /**
     * 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.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * Compute the next hash code. The static synchronization used here
     * should not be a performance bottleneck. When ThreadLocals are
     * generated in different threads at a fast enough rate to regularly
     * contend on this lock, memory contention is by far a more serious
     * problem than lock contention.
     */
    private static synchronized int nextHashCode() {
        int h = nextHashCode;
        nextHashCode = h + HASH_INCREMENT;
        return h;
    }

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

    /**
     * Returns the value in the current thread's copy of this thread-local
     * variable.  Creates and initializes the copy if this is the first time
     * the thread has called this 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)
            return (T)map.get(this);

        // Maps are constructed lazily.  if the map for this thread
        // doesn't exist, create it, with this ThreadLocal and its
        // initial value as its only entry.
        T value = initialValue();
        createMap(t, value);
        return value;
    }

    /**
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Many applications will have no need for
     * this functionality, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current threads' copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

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

    /**
     * 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
     * @param map the map to store.
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    .......

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

    ........

    }

}



可以看到ThreadLocal类中的变量只有这3个int型：
Java 代码

   1. private final int threadLocalHashCode = nextHashCode(); 
   2. private static int nextHashCode = 0; 
   3. private static final int HASH_INCREMENT = 0x61c88647; 

    private final int threadLocalHashCode = nextHashCode();
    private static int nextHashCode = 0;
    private static final int HASH_INCREMENT = 0x61c88647;


而作为ThreadLocal实例的变量只有 threadLocalHashCode 这一个，nextHashCode 和HASH_INCREMENT 是ThreadLocal类的静态变量，实际上HASH_INCREMENT是一个常量，表示了连续分配的两个ThreadLocal实例的 threadLocalHashCode值的增量，而nextHashCode 的表示了即将分配的下一个ThreadLocal实例的threadLocalHashCode 的值。

可以来看一下创建一个ThreadLocal实例即new ThreadLocal()时做了哪些操作，从上面看到构造函数ThreadLocal()里什么操作都没有，唯一的操作是这句：
Java 代码

   1. private final int threadLocalHashCode = nextHashCode(); 

    private final int threadLocalHashCode = nextHashCode();


那么nextHashCode()做了什么呢：
Java 代码

   1. private static synchronized int nextHashCode() { 
   2.     int h = nextHashCode; 
   3.     nextHashCode = h + HASH_INCREMENT; 
   4.     return h; 
   5. } 

    private static synchronized int nextHashCode() {
        int h = nextHashCode;
        nextHashCode = h + HASH_INCREMENT;
        return h;
    }

就是将ThreadLocal类的下一个hashCode值即nextHashCode的值赋给实例的 threadLocalHashCode，然后nextHashCode的值增加HASH_INCREMENT这个值。

因此ThreadLocal实例的变量只有这个threadLocalHashCode，而且是final的，用来区分不同的 ThreadLocal实例，ThreadLocal类主要是作为工具类来使用，那么ThreadLocal.set()进去的对象是放在哪儿的呢？

看一下上面的set()方法，两句合并一下成为
Java 代码

   1. ThreadLocalMap map = Thread.currentThread().threadLocals; 

        ThreadLocalMap map = Thread.currentThread().threadLocals;


这个ThreadLocalMap 类是ThreadLocal中定义的内部类，但是它的实例却用在Thread类中：
Java 代码

   1. public class Thread implements Runnable { 
   2.     ...... 
   3.  
   4.     /* ThreadLocal values pertaining to this thread. This map is maintained
   5.      * by the ThreadLocal class. */ 
   6.     ThreadLocal.ThreadLocalMap threadLocals = null;   
   7.     ...... 
   8. } 

public class Thread implements Runnable {
    ......

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



再看这句：
Java 代码

   1. if (map != null) 
   2.     map.set(this, value); 

        if (map != null)
            map.set(this, value);


也就是将该ThreadLocal实例作为key，要保持的对象作为值，设置到当前线程的ThreadLocalMap 中，get()方法同样大家看了代码也就明白了，ThreadLocalMap 类的代码太多了，我就不帖了，自己去看源码吧。

写这篇帖子的目的不是为了来剖析ThreadLocal，因为坛子里有许多高手已经深入浅出的把ThreadLocal讲解的很清楚了。

特别是lujh99的正确理解ThreadLocal这篇帖子，通过JDK源代码把ThreadLocal讲得非常深入浅出，让我深受启发。我写这篇帖子的目的只是为再此作一个补充，想以另外一种通俗易懂的表达方式把自己对ThreadLocal理解写出来。




lujh99 写道
总之，ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点：
1。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的 ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

 

正如lujh99 所言，ThreadLocal不是用来解决对象共享访问问题的，而是为了处理在多线程环境中，某个方法处理一个业务，需要递归依赖其他方法时，而要在这些方法中共享参数的问题。例如有方法a()，在该方法中调用了方法b()，而在b方法中又调用了方法c()，即a-->b--->c，如果 a，b，c都需要使用用户对象，那么我们常用做法就是a(User user)-->b(User user)---c(User user)。但是如果使用ThreadLocal我们就可以用另外一种方式解决：

   1.   在某个接口中定义一个静态的ThreadLocal 对象，例如 public static ThreadLocal  threadLocal=new ThreadLocal ();
   2.   然后让a，b，c方法所在的类假设是类A，类B，类C都实现1中的接口
   3.   在调用a时，使用A.threadLocal.set(user) 把user对象放入ThreadLocal环境
   4.   这样我们在方法a，方法b，方法c可以在不用传参数的前提下，在方法体中使用threadLocal.get()方法就可以得到user对象。

   上面的类A，类B ，类C就可以分别对应我们做web开发时的 web层的Action--->业务逻辑层的Service-->数据访问层的DAO，当我们要在这三层中共享参数时，那么我们就可以使用 ThreadLocal 了。



    那么user对象是如何存放到ThreadLocal 中的？
lujh99 写道
将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的 ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。

  

    经过我的测试，正是如此，当我们调用A.threadLocal.set(user) 时，set()做了以下几件事：

   1. 得到当前线程Thread 对象
   2. 通过当前线程对象得到当前线程的ThreadLocalMap 对象
   3. 将ThreadLocal静态实例作为key,user对象作值，存放到ThreadLocalMap 中。

PS:因为ThreadLocal是静态的，所以每个线程中的 ThreadLocalMap的key都是相同的，不同的只是存放的容器ThreadLocalMap。



总结：

   其实ThreadLocal 跟我们做web开发时使用的session对象的作用很类似，每当我们向服务器发送一个请求时，web服务器会为该请求创建一个线程，同时会为该请求创建一系列对象，其中包括session（当然在同一个浏览器发送的请求都获得是同一个session对象），所以当我们做web开发时，可以不用担心线程安全问题，自由的往session中存取变量，保存用户状态。同理，当我们在程序中第一次使用A.threadLocal.set(user) 存放参数时，不管在程序的哪个地方，我们都可以通过ThreadLocal  所在的接口访问静态threadLocal对象，同时来共享threadLocal存放的参数，threadLocal就相当于session的作用，来保存当前线程的状态。在我们开发实际开发中，可以任意往threadLocal中共享和存取自己需要的变量，只不过web中的session的生命周期在于客户端的浏览器，而threadLocal中存储的变量的生命周期只在于当前线程，当前结束，threadLocal中存放的参数也被销毁。