底层结构

先看以下代码：

  1. public static void main(String[] args) {
  2.         ThreadLocal threadLocal1 = new ThreadLocal();
  3.         ThreadLocal threadLocal2 = new ThreadLocal();
  4.         Thread T1 = new Thread(() -> {
  5.             threadLocal1.set(1);
  6.             threadLocal2.set(2);
  8.             System.out.println(Thread.currentThread().getName()+threadLocal1.get());
  9.             System.out.println(Thread.currentThread().getName()+threadLocal2.get());
  10.         });
  11.         Thread T2 = new Thread(() -> {
  12.             threadLocal1.set(3);
  13.             threadLocal2.set(4);
  15.             System.out.println(Thread.currentThread().getName()+threadLocal1.get());
  16.             System.out.println(Thread.currentThread().getName()+threadLocal2.get());
  17.         });
  18.         T1.start();
  19.         T2.start();
  20.     }

它所对应的底层结构图为:
image.png
每个 Thread 都有一个 ThreadLocal.ThreadLocalMap 对象。
当调用一个 ThreadLocal 的 set(T value) 方方法时,先得到当前线程的 ThreadLocalMap 对象,然后将
ThreadLocal->value 键值对插入到该 Map 中。

  1. public void set(T value) {
  2.         Thread t = Thread.currentThread();
  3.         ThreadLocalMap map = getMap(t);
  4.         if (map != null)
  5.             map.set(this, value);
  6.         else
  7.             createMap(t, value);
  8. }

get() 方法也是先获得当前线程，然后获取当前线程的ThreadLocalMap，然后传入ThreadLocal来获得值。

应用场景一

ThreadLocal 用作保存每个线程独享的对象，为每个线程都创建一个副本，这样每个线程都可以修改自己所拥有的副本, 而不会影响其他线程的副本，确保了线程安全。

这种场景通常用于保存线程不安全的工具类，典型的需要使用的类就是 SimpleDateFormat。
在这种情况下，每个Thread内都有自己的实例副本，且该副本只能由当前Thread访问到并使用，相当于每个线程内部的本地变量，这也是ThreadLocal命名的含义。因为每个线程独享副本，而不是公用的，所以不存在多线程间共享的问题。
比如有10个线程都要用到SimpleDateFormat

  1. public class ThreadLocalDemo01 {
  3.     public static void main(String[] args) throws InterruptedException {
  5.         for (int i = 0; i < 10; i++) {
  6.             int finalI = i;
  7.             new Thread(() -> {
  8.                 String data = new ThreadLocalDemo01().date(finalI);
  9.                 System.out.println(data);
  10.             }).start();
  11.             Thread.sleep(100);
  12.         }
  14.     }
  16.     private String date(int seconds){
  17.         Date date = new Date(1000 * seconds);
  18.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
  19.         return simpleDateFormat.format(date);
  20.     }
  21. }

我们给每个线程都创建了SimpleDateFormat对象，他们之间互不影响，代码是可以正常执行的。输出结果：

  1. 00:00
  2. 00:01
  3. 00:02
  4. 00:03
  5. 00:04
  6. 00:05
  7. 00:06
  8. 00:07
  9. 00:08
  10. 00:09

我们用图来看一下当前的这种状态：
ThreadLocal - 图2
如果有1000个线程都用到SimpleDateFormat对象呢？
我们一般不会直接去创建这么多线程，而是通过线程池，比如：

  1. public class ThreadLocalDemo011 {
  2.    public static ExecutorService threadPool = Executors.newFixedThreadPool(16);
  4.     public static void main(String[] args) throws InterruptedException {
  6.         for (int i = 0; i < 1000; i++) {
  7.             int finalI = i;
  8.             threadPool.submit(() -> {
  9.                 String data = new ThreadLocalDemo011().date(finalI);
  10.                 System.out.println(data);
  11.             });
  12.         }
  13.         threadPool.shutdown();
  14.     }
  16.     private String date(int seconds){
  17.         Date date = new Date(1000 * seconds);
  18.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("mm:ss");
  19.         return simpleDateFormat.format(date);
  20.     }
  22. }

可以看出，我们用了一个16线程的线程池，并且给这个线程池提交了1000次任务。每个任务中它做的事情和之前是一样的，还是去执行date方法，并且在这个方法中创建一个simpleDateFormat 对象。结果：

  1. 00:00
  2. 00:07
  3. 00:04
  4. 00:02
  5. ...
  6. 16:29
  7. 16:28
  8. 16:27
  9. 16:26
  10. 16:39

我们刚才所做的就是每个任务都创建了一个 simpleDateFormat 对象，也就是说，1000 个任务对应 1000 个 simpleDateFormat 对象，但是如果任务数巨多怎么办？
这么多对象的创建是有开销的，并且在使用完之后的销毁同样是有开销的，同时存在在内存中也是一种内存的浪费。
我们可能会想到，要不所有的线程共用一个 simpleDateFormat 对象？但是simpleDateFormat 又不是线程安全的，我们必须做同步，比如使用synchronized加锁。到这里也许就是我们最终的一个解决方法。但是使用synchronized加锁会陷入一种排队的状态，多个线程不能同时工作，这样一来，整体的效率就被大大降低了。有没有更好的解决方案呢？

使用ThreadLocal

对这种场景，ThreadLocal再合适不过了，ThreadLocal给每个线程维护一个自己的simpleDateFormat对象，这个对象在线程之间是独立的，互相没有关系的。这也就避免了线程安全问题。与此同时，simpleDateFormat对象还不会创造过多，线程池一共只有 16 个线程，所以需要16个对象即可。

  1. public class ThreadLocalDemo04 {
  3.     public static ExecutorService threadPool = Executors.newFixedThreadPool(16);
  5.     public static void main(String[] args) throws InterruptedException {
  7.         for (int i = 0; i < 1000; i++) {
  8.             int finalI = i;
  9.             threadPool.submit(() -> {
  10.                 String data = new ThreadLocalDemo04().date(finalI);
  11.                 System.out.println(data);
  12.             });
  13.         }
  14.         threadPool.shutdown();
  15.     }
  17.     private String date(int seconds){
  18.         Date date = new Date(1000 * seconds);
  19.         SimpleDateFormat dateFormat = ThreadSafeFormater.dateFormatThreadLocal.get();
  20.         return dateFormat.format(date);
  21.     }
  22. }
  24. class ThreadSafeFormater{
  25.     public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = ThreadLocal.withInitial(() -> new SimpleDateFormat("mm:ss"));
  26. }

我们用图来看一下当前的这种状态：
ThreadLocal - 图3

应用场景二

每个线程内需要保存类似于全局变量的信息（例如在拦截器中获取的用户信息），可以让不同方法直接使用，避免参数传递的麻烦却不想被多线程共享（因为不同线程获取到的用户信息不一样）。
例如，用 ThreadLocal 保存一些业务内容（用户权限信息、从用户系统获取到的用户名、用户ID 等），这些信息在同一个线程内相同，但是不同的线程使用的业务内容是不相同的。
在线程生命周期内，都通过这个静态 ThreadLocal 实例的 get() 方法取得自己 set 过的那个对象，避免了将这个对象（如 user 对象）作为参数传递的麻烦。
比如说我们是一个用户系统，那么当一个请求进来的时候，一个线程会负责执行这个请求，然后这个请求就会依次调用service-1()、service-2()、service-3()、service-4()，这4个方法可能是分布在不同的类中的。

我们用图画的形式举一个实例：
ThreadLocal - 图4

  1. package com.kong.threadlocal;
  4. public class ThreadLocalDemo05 {
  5.     public static void main(String[] args) {
  6.         User user = new User("jack");
  7.         new Service1().service1(user);
  8.     }
  10. }
  12. class Service1 {
  13.     public void service1(User user){
  14.         //给ThreadLocal赋值，后续的服务直接通过ThreadLocal获取就行了。
  15.         UserContextHolder.holder.set(user);
  16.         new Service2().service2();
  17.     }
  18. }
  20. class Service2 {
  21.     public void service2(){
  22.         User user = UserContextHolder.holder.get();
  23.         System.out.println("service2拿到的用户:"+user.name);
  24.         new Service3().service3();
  25.     }
  26. }
  28. class Service3 {
  29.     public void service3(){
  30.         User user = UserContextHolder.holder.get();
  31.         System.out.println("service3拿到的用户:"+user.name);
  32.         //在整个流程执行完毕后，一定要执行remove
  33.         UserContextHolder.holder.remove();
  34.     }
  35. }
  37. class UserContextHolder {
  38.     //创建ThreadLocal保存User对象
  39.     public static ThreadLocal<User> holder = new ThreadLocal<>();
  40. }
  42. class User {
  43.     String name;
  44.     public User(String name){
  45.         this.name = name;
  46.     }
  47. }

执行的结果：

  1. service2拿到的用户:jack
  2. service3拿到的用户:jack