ThreadLocal使用及原理

1.ThreadLocal的简单使用

从ThreadLocal的名字上可以看到，这是个线程的局部变量。也就是说只有当前线程可以访问，既然是只有当前线程池可以访问的数据自然是线程安全的。

package thread;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadLocalDemo {

	private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>();

//如果不想要下面的t1.set则可以通过这种方式构造ThreadLocal.
//	private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>() {
//		public SimpleDateFormat initialValue() {
//			return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//		}
//	};
	private static final SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	private static ReentrantLock lock = new ReentrantLock();

	public static class ParseDate implements Runnable {

		int i = 0;

		public ParseDate(int i) {
			this.i = i;
		}

		// @Override
		// public void run() {
		// try {
		// lock.lock();
		// Date date = sm.parse("2018-8-12 17:30:" + i + "");
		// System.out.println(i + "--" + date);
		// lock.unlock();
		// Thread.sleep(1000);
		// } catch (ParseException e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// } catch (InterruptedException e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// }
		// }

		// @Override
		// public void run() {
		// try {
		// synchronized (ParseDate.class) {
		// Date date = sm.parse("2018-8-12 17:30:"+i+"");
		// System.out.println(i+"--"+date);
		// }
		// Thread.sleep(1000);
		// } catch (ParseException e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// } catch (InterruptedException e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// }
		// }

		@Override
		public void run() {
			if (t1.get() == null)
				t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

			try {
				Date date = t1.get().parse("2018-8-12 17:30:" + i + "");
				System.out.println(i + "--" + date);
				Thread.sleep(1000);
			} catch (ParseException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}

	public static void main(String[] args) {
		ExecutorService es = Executors.newFixedThreadPool(10);

		for (int i = 0; i < 30; i++)
			es.execute(new ParseDate(i));
	}

}

可以看到输出结果也是正确地。这里我有三种方式保证线程的安全性，锁和重入锁还有就是ThreadLocal。在线程ThreadLocal中if (t1.get() == null)
                t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

这两行代码的含义是，如果当前线程不持有SimpleDateFormat对象的实例则新建一个并将其设置到当前线程中。如果有则直接使用。从这里也可以看到为每个线程人手分配一个对象的工作并不是由ThreadLocal来完成的而是在应用层保证的。如果在应用上为每一个线程分配相同的对象实例，那么ThreadLocal也不能保证线程安全。（注意：为每个线程分配不同的对象，需要在应用层保证。ThreadLocal只是起到简单容器的作用。）

2.ThreadLocal的实现原理

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

首先它会获取当前线程对象，然后通过getMap()拿到线程ThreadLocalMap，然后将值设入ThreadLocalMap中。（ThreadLocalMap可以简单的理解为一个Map，它是定义在Thread内部的成员。）

设置到ThreadLocal中的数据，也是写入了threadLocals这个Map中。其中key为ThreadLocal当前对象，value则是我们需要的值这里是：new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")。而threadLocals本身就保存了当前自己所在线程的所有局部变量，也就是一个ThreadLocal变量的集合。

get()操作：

 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

它也是先获取当前线程的ThreadLocalMap对象，然后通过将自己作为key取得内部的实际数据。

因为这些变量是维护在Thread类内部的,所以这意味着只要线程不退出，对象的引用将一直存在。而当线程退出时，Thread类会进行清理工作：

因此如果使用线程池，这就意味着当前线程未必会退出（比如固定大小的线程池。）如果这样将一些太大的对象设置到ThreadLocal中（实际会保存在线程持有的threadLocals Map中）。可能会使系统出现内存泄露的可能。

此时如果希望及时的回收对象，最好使用ThreadLocal.remove()方法将这个变量移除。或者可以直接通过将ThreadLocal对象设为null的方式，让系统自行垃圾回收。

ThreadLocal的使用场景一般是共享对象对于竞争的处理容易引起性能的损失，这时候可以考虑使用ThreadLocal为每个线程分配单独的对象。