浅谈ThreadLocal

1. 什么是ThreadLocal

ThreadLocal是一个提供线程本地变量（线程局部变量 / thread-local variables）的类。每一个通过set或get方法访问ThreadLocal变量的线程，都会生成独立的，只属于这个线程变量的副本（“every thread that accesses a ThreadLocal variable via its get or set method has its own, independently initialized copy of the variable”）

简单来讲，ThreadLocal为线程一个变量的副本，而此副本不会和其它线程的变量副本冲突。

只要线程是活动的并且 ThreadLocal 实例是可访问的，每个线程都保持对其线程本地变量副本的隐式引用；在线程消失之后，其线程本地实例的所有副本都会被垃圾回收（除非存在对这些副本的其他引用）。

线程本地变量是static和final的。

 

2. ThreadLocal有什么用

• ThreadLocal是现实线程安全(thread-safe)的一种方式。通过为每一个线程都提供了一份变量，线程同时访问变量而互不影响，典型的“空间换时间”。

• ThreadLocal提供一种方式，可以使其状态与某一个线程（例如，用户 ID 或事务 ID）相关联。

 

3. ThreadLocal类

public class ThreadLocalDateUtil implements IDateUtil {
    
    private static final ThreadLocal<SimpleDateFormat> sdf = new ThreadLocal<SimpleDateFormat>(){
        
        @Override
        public SimpleDateFormat get(){
             return super.get();
        }
        
        /**
         *   Returns the current thread's "initial value" for this thread-local variable.
         *   如果不覆盖initialValue，第一次get返回null
         */
        @Override
        public SimpleDateFormat initialValue(){
            return new SimpleDateFormat("yyyy MM dd");
        }
        
        @Override
        public void set(SimpleDateFormat value){
            super.set(value);
        }
        
        /**
         * 移除此线程局部变量的值。这可能有助于减少线程局部变量的存储需求。
         * 如果再次访问此线程局部变量，那么在默认情况下它将拥有其 initialValue。
         */
        @Override
        public void remove(){
            super.remove();
        }
    };

    public String convertString2Date(Date date) throws ParseException{
        return sdf.get().format(date);
    }
}

ThreadLocal方法不多，其中get(),set()和remove()无需过多描述。initialValue()无需现实调用，一般都重写initialValue方法，以给定一个特定的初始值。

 

4. ThreadLocal实例

利用ThreadLocal解决SimpleDateFormat线程安全的问题（3.ThreadLocalDateUtil），并比较ThreadLocal方法和Synchronized方法。

以下是使用Synchronized的方法：

/**
 * 使用同步机制解决SimpleDateFormat线程安全问题
 * @author ccycyang
 *
 */
public class SynDateUtil implements IDateUtil {

    private SimpleDateFormat sdf = new SimpleDateFormat("yyyy MM dd");
    
    public String convertString2Date(Date date) throws ParseException{
        String result;
        synchronized (sdf) {
            result = sdf.format(date);
        }
        return result;
    }
}

 

一下是测试类，使用了CyclicBarrier来控制线程：

/**
 * Refer to JCIP Chapter 12
 * @author ccycyang
 *
 */
public class TestSimpleDateFormat {
    
    private static final ExecutorService pool = Executors.newCachedThreadPool();
    private final CyclicBarrier barrier; //Make sure all the threads is ready
    private final BarrierTimer timer; //Calculate the time
    private int nParis; //thread number
    
    public TestSimpleDateFormat(int nParis) {
        // TODO Auto-generated constructor stub
        this.nParis = nParis;
        this.timer = new BarrierTimer();
        this.barrier=new CyclicBarrier(nParis+1);
    }

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        
        new TestSimpleDateFormat(5000).test(false);

        pool.shutdown();
    }
    
    private void test(boolean isSyn){
        try{
            timer.clear();
            for(int i=0;i<nParis;i++){
                pool.execute(timer);
                if(isSyn){
                    pool.execute(new AccessDateThread(new SynDateUtil()));
                }else{
                    pool.execute(new AccessDateThread(new ThreadLocalDateUtil()));
                }
            }
            barrier.await(); //wait for all thread's ready.
            barrier.await(); //wait for all thread's finished
            
            long nsPerTrai = timer.getTime() / nParis;
            System.out.println("Throughput: "+nsPerTrai);
        }catch(Exception e){
            throw new RuntimeException(e);
        }
        
    }
    
    class AccessDateThread implements Runnable {
        private IDateUtil dateUtil;
        
        public AccessDateThread(IDateUtil du){
            this.dateUtil = du;
        }        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                
                barrier.await();
                
                dateUtil.convertString2Date(new Date());
                
                barrier.await();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }
    
    //JCIP Chapter 12
    class BarrierTimer implements Runnable{
        private boolean started;
        private long startTime,endTime;
        
        public synchronized void run(){
            long t=System.nanoTime();
            if(!started){
                started=true;
                startTime = t;
            }else{
                endTime = t;
            }
        }
        
        public synchronized void clear(){
            started = false;
        }
        public synchronized long getTime(){
            return endTime - startTime;
        }
    }
}

 

测试结果显示ThreadLocal确实比Synchronized有提升，时间会短些

apache commons-lang包的DateFormatUtils或者FastDateFormat实现，apache保证是线程安全的，并且更高效。

 

有时间要看看commons-lang包里的FormatUtils怎么实现。

 

Update: ThreadLocal有可能会导致Memory Leak:

http://javarevisited.blogspot.co.at/2013/01/threadlocal-memory-leak-in-java-web.html 

 

参考：

JDK： http://docs.oracle.com/javase/6/docs/api/java/lang/ThreadLocal.html 

Java Best Practices: http://www.javacodegeeks.com/2010/07/java-best-practices-dateformat-in.html