JAVA ThreadLocal对象用法

使用ThreadLocal对象有两个主要的功能：

1. 实现对同一个实例化对象不同线程属性值得分离；
2. 同一个会话（线程）中对象值的传递。

以下两个类用来解释ThreadLocal对象的两个功能，MyThreadLocal：单例类，具有一个ThreadLocal对象的属性；TestRunnable：实现线程接口Runnable，在run方法中，获取MyThreadLocal对象的单例->获取使用ThreadLocal对象存储的值->设置ThreadLocal对象的新值。

为了能够直观的看出ThreadLocal对象值的改变，使用两个线程，并且设置ThreadLocal对象的值后暂停线程1s。

以下是具体代码：

MyThreadLocal类：

public class MyThreadLocal {
    private ThreadLocal<Integer> flag = new ThreadLocal<Integer>() ;
   
    private static MyThreadLocal local = new MyThreadLocal() ;
   
    private MyThreadLocal(){
    }
    /**
     * 通过单例获取一个实例化的对象
     * @return
     */
    public static MyThreadLocal getInstance(){
        return local ;
    }
   
    public void setFlagValue(int num){
        flag.remove() ;
        flag.set(num) ;
    }
   
    public int getFlagValue(){
        if(flag.get()==null){
            return 0 ;
        }
        return flag.get() ;
    }

    public ThreadLocal<Integer> getFlag() {
        return flag;
    }

    public void setFlag(ThreadLocal<Integer> flag) {
        this.flag = flag;
    }
   
}

 

 

TestRunnable类：

public class TestRunnable implements Runnable {
    private String name ;
   
    public TestRunnable(String name){
        this.name = name ;
    }
   
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
   
    /**
     * 在设置值之前首先输出通过ThreadLocal对象保存的值，设置新值后再经过sleep，
     * 使其他的线程能够操作同一个对象的属性。
     */
    @Override
    public void run() {
        MyThreadLocal myThreadLocal = MyThreadLocal.getInstance() ;
        for (int i = 0; i < 10; i++) {
            System.out.println(name+" 前-> "+myThreadLocal.getFlagValue()) ;
            if(name.indexOf("1")>-1){
                myThreadLocal.setFlagValue(i) ;
            }
           
            try {
                if(name.indexOf("1")>-1&&i%2==0){
                    Thread.currentThread().sleep(1000) ;
                }
               
                if(name.indexOf("2")>-1&&i%2==1){
                    Thread.currentThread().sleep(1000) ;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name+" 后-> "+myThreadLocal.getFlagValue()) ;
        }
    }
   
    public static void main(String[] args) {
        Thread thread1 = new Thread(new TestRunnable("thread1")) ;
        Thread thread2 = new Thread(new TestRunnable("thread2")) ;
       
        thread1.start();
        thread2.start();
    }

}

 

运行一次的结果如下：

thread1 前-> 0
thread2 前-> 0
thread2 后-> 0
thread2 前-> 0
thread2 后-> 0
thread1 后-> 0
thread2 前-> 0
thread1 前-> 0
thread2 后-> 0
thread1 后-> 1
thread2 前-> 0
thread1 前-> 1
thread2 后-> 0
thread1 后-> 2
thread1 前-> 2
thread2 前-> 0
thread1 后-> 3
thread2 后-> 0
thread1 前-> 3
thread2 前-> 0
thread2 后-> 0
thread2 前-> 0
thread2 后-> 0
thread2 前-> 0
thread1 后-> 4
thread1 前-> 4
thread1 后-> 5
thread1 前-> 5
thread1 后-> 6
thread1 前-> 6
thread2 后-> 0
thread2 前-> 0
thread2 后-> 0
thread2 前-> 0
thread1 后-> 7
thread1 前-> 7
thread2 后-> 0
thread1 后-> 8
thread1 前-> 8
thread1 后-> 9

由结果中可以看出：通过单例类设置和获取的值是某个线程自己的值，不同的线程之间没有共享ThreadLocal对象的值。

 

另参考了http://www.iteye.com/topic/103804如下内容：

首先，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实例作为key，要保持的对象作为值，设置到当前线程的ThreadLocalMap 中。

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

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

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