解读 ThreadLocal

一、ThreadLocal的简单使用

ThreadLocal是一个线程的局部变量，只有当前线程可以访问，所以是线程安全的。

邀你观看下边代码，你觉得会有问题吗？

1. //主要任务完成日期的转换

2.    private static final SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

3.    public static class ParseDate implements Runnable{

4.        int i=0;

5.        public ParseDate(int i){

6.            this.i=i;

7.        }

8.        @Override

9.        public void run() {

10.            try {

11.                Date  t=sdf.parse("2015-03-29 19:29:"+i%60);

12.                System.out.println(i+":"+t);

13.            } catch (ParseException e) {

14.                e.printStackTrace();

15.            }

16.        }

17.    }

19.    public static void main(String[] args) {

20.        ExecutorService es=Executors.newFixedThreadPool(10);

21.        //通过线程执行不同的Runnable，但是Runnable使用的是同一个SimpleDateFormat

22.        for(int i=0;i<1000;i++){

23.            es.execute(new ParseDate(i));

24.        }

25.        es.shutdown();

26.    }

如果你发现了问题，是不是考虑到了SimpleDateFormat 类的parse()方法不是线程安全的，所以程序运行过程中，可能会报错。

或许你会想到在parse方法前后加锁，这也是一种可行的方法。今天我们来学习使用新的技能ThreadLocal。

1. static ThreadLocal<SimpleDateFormat> t1=new ThreadLocal<SimpleDateFormat>();

2.    public static class ParseDate implements Runnable{

3.        int i=0;

4.        public ParseDate(int i){

5.            this.i=i;

6.        }

7.        @Override

8.        public void run() {

9.            try {

10.                //如果当前线程没有SimpleDateFormat实例，则为当前线程创建。否则，直接获取。

11.                if(t1.get()==null){

12.                    t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

13.                }

14.                Date  t=t1.get().parse("2015-03-29 19:29:"+i%60);

15.                System.out.println(i+":"+t);

16.            } catch (ParseException e) {

17.                e.printStackTrace();

18.            }

19.        }

20.    }

为每一个线程分配不同的对象，需要在应用层面保证。ThreadLocal起到了简单的容器作用。

二、ThreadLocal的实现原理

我们主要来学习ThreadLocal的set()和get()方法。

1、set()方法。

1. public void set(T value) {

2.        //获取当前线程

3.        Thread t = Thread.currentThread();

4.        //获取于当前线程有关的ThreadLocalMap对象实例

5.        ThreadLocalMap map = getMap(t);

6.        //如果不为空则设置值，如果为空则创建且设置值。

7.        if (map != null)

8.            map.set(this, value);

9.        else

10.            createMap(t, value);

11.    }

13. void createMap(Thread t, T firstValue) {

14.        t.threadLocals = new ThreadLocalMap(this, firstValue);

15.  }

ThreadLocalMap可以理解为一个map，它是定义在Thread内部的成员，但是ThreadLocal的静态内部类。

Thread类中有如下定义：

1. ThreadLocal.ThreadLocalMap threadLocals = null;

2、get():获取与当前线程相关的对象

1. public T get() {

2.        //获取当前线程

3.        Thread t = Thread.currentThread();

4.        //获取当前线程的map

5.        ThreadLocalMap map = getMap(t);

6.        if (map != null) {

7.            ThreadLocalMap.Entry e = map.getEntry(this);

8.            if (e != null) {

9.                @SuppressWarnings("unchecked")

10.                T result = (T)e.value;

11.                return result;

12.            }

13.        }

14.        return setInitialValue();

15.    }

三、ThreadLocal回收机制

1、Thread.exit()

变量维护在Thread类内部的（因为Thread类内部有ThreadLocalMap对象），所以线程不退出，对象的引用将一直存在。当线程退出后，Thread类会进行一些清理工作，其中，包括对ThreadLocalMap的清理。

1. private void exit() {

2.        ......

3.        /* Speed the release of some of these resources */

4.        threadLocals = null;

5.       ......

6.    }

2、ThreadLocalMap

1. //实现了ThreadLocal的弱引用

2. static class Entry extends WeakReference<ThreadLocal<?>> {

3.            /** The value associated with this ThreadLocal. */

4.            Object value;

6.            Entry(ThreadLocal<?> k, Object v) {

7.                super(k);

8.                value = v;

9.            }

10.        }

ThreadLocal的外部引用被回收时候，那么ThreadLocalMap中的key就会变成null。当系统进行ThreadLocalMap清理时，就会自然将这些垃圾数据回收。