正确理解ThreadLocal

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

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

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

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

    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源码）

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型：

    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()里什么操作都没有，唯一的操作是这句：

    private final int threadLocalHashCode = nextHashCode();

那么nextHashCode()做了什么呢：

    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()方法，两句合并一下成为

        ThreadLocalMap map = Thread.currentThread().threadLocals;

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

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

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

再看这句：

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

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

写了这么多，也不知讲明白了没有，有什么不当的地方还请大家指出来。

评论

19 楼 小琼樱 2012-09-05  

http://blog.csdn.net/qjyong/article/details/2158097 觉得这个写得更加好理解写
当然楼主写得也很有帮助

18 楼 moshalanye 2008-06-06  

青蛙支持下你！ 呵呵！
个人理解： 这个 静态变量 ThreadLocal.ThreadLocalMap threadLocals 从实现上放在哪里都一样可以，只是规范和语义上来说放在Thread 里面更合理，
Thread t = Thread.currentThread(); 用来获得存放map的对象也更快捷（nitive方法麻）

既然threadLocal 是key  那么不同线程使用同一个threadLocal对象 ，那么他们存什么进去肯定都会覆盖原来的其他线程存进去

如果不同线程 使用不同的 threadLocal对象 存的value 是同一个对象 ，那么他们就在共享一个value ，这个时候 value  就是一个多线程的 resource  这个时候就是要考虑下并发安全了  ：）
不过好像把resource作为共享数据buffer来操作不大合理，一般这样的buffer都是拥有自己的业务需求了，不够common，应该自己另外定义一个共享数据源给多个线程作为私有数据或是（共享数据源是静态的可供线程访问）， 而不是通过local放到map里去  

一般看到的使用local的用法，都是存放一些数据库资源信息或是session（信息量少）


to ：  csrcom    有点不明白为什么要这么做，set的value 是obejct ，自己定义的类 和jdk 的集合类  不都是object的麻 ，只是进去出来转一下就好


现在我有个新问题： 希望有人解答

我看到在ThreadLocal类实现中 只看到remove()方法，那么我是否可以这么理解？在拥有 ThreadLocal对象（有可能是静态对象，也可能不是静态对象） 的线程结束时一定的记得判断 从local 塞进去的value 是否还需要，如果不需要了，然而没有调用remove()方法，多出现几次 Thread 中静态的 localMap 会只进不出越来越大，也就是无意思的内存未回收  
这样的情况是否都必须自己来做 remove（） 回收， 还是有其他的机制已经做了这件事？


希望大家别吝啬手上的石头，砸到我醒为止！ ：）  

17 楼 spiritfrog 2008-06-06  

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

其他线程能否访问，还要看你的get和set怎么写了， 如果两个线程都存入同一个对象引用，那就会有线程共享问题。

16 楼 neptune 2008-06-05  

那你就看看spring事务管理是如果实现的好了

15 楼 suntiance 2008-06-05  

总结的不错。可以把各种框架和容器对ThreadLocal的应用拿来一起分析一下，看看究竟有什么神奇的地方。

14 楼 wuyingsong 2008-06-05  

jieyuan_cg 写道

LZ的这篇对ThreadLocal的解释真到位。。。多谢！
坛子里面有几篇对ThreadLocal的解释好像都有些误解。。。看得晕晕乎乎。

13 楼 tenderghost 2008-06-03  

学习了，有机会用一下。

12 楼 class_syh 2008-05-26  

受教了，只是用过，没有分析这么透彻。

11 楼 racnow 2008-05-26  

受益，真正理解ThreadLocal了，收藏

10 楼 csrcom 2008-05-22  

其实可以在thread local存放更丰富的对象比如Map，那么就不用实例化那么thread local了

package com.meidusa.amoeba.util;

import java.util.HashMap;
import java.util.Map;

import org.apache.log4j.Logger;
/**
 * ThreadLocal Context
 * @author <a href=mailto:[e-mail]>Struct chen</a>
 * @version $Id: ThreadLocalContext.java 3597 2006-11-23 08:11:58Z struct $
 */
public class ThreadLocalMap{
	private static Logger logger = Logger.getLogger(ThreadLocalMap.class);
	
	protected final static ThreadLocal<Map<String,Object>> threadContext = new MapThreadLocal();
	
	private ThreadLocalMap(){};
	
	public static void put(String key,Object value){
		getContextMap().put(key,value);
	}
	
	public static Object remove(String key){
		return getContextMap().remove(key);
	}
	
	public static Object get(String key){
		return getContextMap().get(key);
	}
	
	private static class MapThreadLocal extends ThreadLocal<Map<String,Object>> {
        protected Map<String,Object> initialValue() {
        	return new HashMap<String,Object>() {
				
        		private static final long serialVersionUID = 3637958959138295593L;
				
				public Object put(String key, Object value) {
                    if (logger.isDebugEnabled()) {
                        if (containsKey(key)) {
                        	logger.debug("Overwritten attribute to thread context: " + key
                                + " = " + value);
                        } else {
                        	logger.debug("Added attribute to thread context: " + key + " = "
                                + value);
                        }
                    }

                    return super.put(key, value);
                }
            };
        }
    }
	
	/**
     * 取得thread context Map的实例。
     *
     * @return thread context Map的实例
     */
    protected static Map<String,Object> getContextMap() {
        return (Map<String,Object>) threadContext.get();
    }
	
    
    /**
     * 清理线程所有被hold住的对象。以便重用！
     */
    
    public static void reset(){
    	getContextMap().clear();
    }
}

9 楼 elice 2008-05-22  

主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式

8 楼 dafei2599 2008-05-13  

LZ简直是神贴,写的真是明了.

7 楼 jieyuan_cg 2008-04-02  

LZ的这篇对ThreadLocal的解释真到位。。。多谢！
坛子里面有几篇对ThreadLocal的解释好像都有些误解。。。看得晕晕乎乎。

6 楼 jieyuan_cg 2008-04-02  

SINCE1978 写道

我想知道如果多次new ThreadLocal并且调用其set方法的话、是否就和普通hashmap一样后set进去的会覆盖先set进去的？这样的话ThreadLocal只能植入一个资源喽？这肯定不对，否则还用ThreadLocalMap这个自定义哈希表干什么，那么如何区分一个线程当中不同方法或不同类set进去的资源？并正确set和get？？

每个ThreadLocal当然只能放一个对象。要是需要放其他的对象，就再new 一个新的ThreadLocal出来，这个新的ThreadLocal作为key,需要放的对象作为value，放在ThreadLocalMap中。。。。

5 楼 SINCE1978 2007-11-16  

我想知道如果多次new ThreadLocal并且调用其set方法的话、是否就和普通hashmap一样后set进去的会覆盖先set进去的？这样的话ThreadLocal只能植入一个资源喽？这肯定不对，否则还用ThreadLocalMap这个自定义哈希表干什么，那么如何区分一个线程当中不同方法或不同类set进去的资源？并正确set和get？？

4 楼 hax 2007-08-21  

lujh99 写道

另外想到一个把map放到各自线程中带来的好处是 因为各线程访问的map是各自不同的map，所以不需要同步，速度会快些；而如果把所有线程要用的对象都放到一个静态map中的话 多线程并发访问需要进行同步。

不是快一点两点的，jdk 1.3之前的实现是非常之慢的！

3 楼 liangguanhui 2007-08-21  

可能是我搞错了，是1.3的时候改写的

2 楼 lujh99 2007-07-23  

liangguanhui 写道

引用

或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中，应该也行，这也是一般人的想法，但事实上，ThreadLocal的实现刚好相反，它是在每个线程中有一个map，而将ThreadLocal实例作为key，这样每个map中的项数很少，而且当线程销毁时相应的东西也一起销毁了，不知道除了这些还有什么其他的好处。

其实在jdk1.4之前的ThreadLocal的实现就是类似第一种情况的实现，jdk1.4就改成后面那种实现。
至于好处，除了可以自动释放外，还有一个很重要的好处：速度快了很多。

不是啊，我看了一下jdk1.3的源码，这一点上和1.4、1.5是一样的，map都是放在每个线程中的，以threadLocal为key，所不同的是，在1.3中这个map是个普通的HashMap，而1.4和1.5中是个ThreadLocalMap类，一个明显的特征是其中的Entry用到了弱引用WeakReference 类，但我感觉这个WeakReference的用法在这里并不能起到应有的作用。

另外想到一个把map放到各自线程中带来的好处是 因为各线程访问的map是各自不同的map，所以不需要同步，速度会快些；而如果把所有线程要用的对象都放到一个静态map中的话 多线程并发访问需要进行同步。

1 楼 liangguanhui 2007-07-23  

引用

或者可以自己定义一个静态的map，将当前thread作为key，创建的session作为值，put到map中，应该也行，这也是一般人的想法，但事实上，ThreadLocal的实现刚好相反，它是在每个线程中有一个map，而将ThreadLocal实例作为key，这样每个map中的项数很少，而且当线程销毁时相应的东西也一起销毁了，不知道除了这些还有什么其他的好处。

其实在jdk1.4之前的ThreadLocal的实现就是类似第一种情况的实现，jdk1.4就改成后面那种实现。
至于好处，除了可以自动释放外，还有一个很重要的好处：速度快了很多。