重点

TheadLocal：用于线程间变量隔离，仅能在当前线程内访问，无法使用ThreadLocal进行父子线程变量传递。
ThreadLocalMap定义在ThreadLocal中的内部类，Thread中存在一个ThreadLocalMap属性
ThreadLocal内部维护的ThreadLocalMap是与当前线程绑定（ThreadLocalMap是当前线程的一个属性）
添加数据时，map的key为当前ThreadLocal实例；一个线程可中可进行多个ThreadLocal创建
当元素冲突时，采用开放寻址方式，而非链表方式。

一、应用场景

在使用多线程情况下，程序在处理用户请求的时候，通常后端服务器是有一个线程池，对每一个请求就分配一个线程来处理，那为了防止多线程并发处理请求的时，发生线程数据安全问题（串数据），利用ThreadLocal实现线程间变量隔离。

使用案例

  1. //存放用户信息的ThreadLocal，一般使用Util类进行封装
  2. private static final ThreadLocal<UserInfo> userInfoThreadLocal = new ThreadLocal<>();
  4. public Response handleRequest(UserInfo userInfo) {
  5.   Response response = new Response();
  6.   try {
  7.     // 1.用户信息set到线程局部变量中
  8.     userInfoThreadLocal.set(userInfo);
  9.     doHandle();
  10.   } finally {
  11.     // 3.使用完移除掉
  12.     userInfoThreadLocal.remove();
  13.   }
  14.   return response;
  15. }
  17. //业务逻辑处理
  18. private void doHandle () {
  19.   // 2.实际用的时候取出来
  20.   UserInfo userInfo = userInfoThreadLocal.get();
  21.   //处理业务操作....
  22. }

二、实现细节

实现总结

ThreadLocal

单个线程可以进行多次执行new ThreadLocal()操作，每次调用ThreadLocal的set()方法或者setInitialValue()方法，都会在内部的ThreadLocalMap中添加一条数据（类似于执行了一次put操作）
key：当前ThreadLocal对象
value：需要存储的线程局部变量

ThreadLocalMap【Thread的一个成员变量】

image.png
当发生hash冲突时，采用开放地址法进行解决冲突

ThreadLocalMap底层使用Entry数组，初始大小16。其中Entry继承WeakReference，仅将Entry的key设置为弱类型**。
image.png

  1.         static class Entry extends WeakReference<ThreadLocal<?>> {
  2.             /** The value associated with this ThreadLocal. */
  3.             Object value;
  5.             Entry(ThreadLocal<?> k, Object v) {
  6.                 //调用父类构造方法，将key设置为弱引用类型
  7.                 super(k);
  8.                 value = v;
  9.             }
  10.         }
  12.     public WeakReference(T referent) {
  13.         super(referent);
  14.     }

key设置为弱引用原因

为了尽最避免内存泄漏，但是如果仅仅这样，还是无法避免内存泄漏。ThreadLocalMap是根据key是否为null来判断是否清理Entry？？？（没找到依据）。
系统一般使用线程池将线程进行复用，线程生命周期很长。根据GC root搜索方式，进行垃圾回收，Thread—>ThreadLocalMap-Entry会一直存在。
**
ThreadLocal的设计者认为只要ThreadLocal 所在的作用域结束了工作被清理了（但有时ThreadLocal并不会顺利清理），GC回收的时候就会把key引用对象回收，key置为null，ThreadLocal会尽力保证Entry清理掉来最大可能避免内存泄漏。

ThreadLocal 所在的作用域结束，并没有清理时，TheadLocal会一直被强引用关联
image.png
**
正常初始化时引用结构image.png

弱引用

只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描内存区域时，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。

具体分析

  1. 实例化方式1
  2.     /**
  3.      * Creates a thread local variable.
  4.      * @see #withInitial(java.util.function.Supplier)
  5.      */
  6.     public ThreadLocal() {
  7.     }
  9. 实例化方式2
  10.     public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
  11.         return new SuppliedThreadLocal<>(supplier);
  12.     }
  13.     //在ThreadLocal中设置变量
  14.     private T setInitialValue() {
  15.         T value = initialValue();
  16.         Thread t = Thread.currentThread();
  17.         //获取当前线程关联的ThreadLocalMap实例
  18.         ThreadLocalMap map = getMap(t);
  19.         if (map != null)
  20.             map.set(this, value);
  21.         else
  22.             //初始化ThreadLocalMap
  23.             createMap(t, value);
  24.         return value;
  25.     }
  28.     ThreadLocalMap getMap(Thread t) {
  29.         return t.threadLocals;
  30.     }
  32.     void createMap(Thread t, T firstValue) {
  33.         t.threadLocals = new ThreadLocalMap(this, firstValue);
  34.     }

三、存在问题与避免

内存泄漏

Entry 继承了WeakReference类，Entry 中的 key 是WeakReference类型的（Value为强引用），在Java 中当对象只被 WeakReference 引用，没有其他对象引用时，被WeakReference 引用的对象发生GC 时会直接被回收掉。

解决方案

手动调用remove函数

  1. class Threadlocal {
  2.   public void remove() {
  3.       //获取当前线程的ThreadLocalMap
  4.       ThreadLocalMap m = getMap(Thread.currentThread());
  5.       if (m != null)
  6.         m.remove(this); //this就是ThreadLocal对象，移除，方法在下面
  7.   }
  8. }
  10. class ThreadlocalMap {
  11.   private void remove(ThreadLocal<?> key) {
  12.     Entry[] tab = table;
  13.     int len = tab.length;
  14.     //获取存储位置
  15.     int i = key.threadLocalHashCode & (len-1);
  16.     for (Entry e = tab[i];
  17.          e != null;
  18.          e = tab[i = nextIndex(i, len)]) {
  19.       //清理
  20.       if (e.get() == key) {
  21.           //调用父类方法，置空引用
  22.         e.clear();
  23.         expungeStaleEntry(i); //清理空槽
  24.         return;
  25.       }
  26.    }
  27.  }
  28. }
  30. //清理数组元素
  31. private int expungeStaleEntry(int staleSlot) {
  32.   Entry[] tab = table;
  33.   int len = tab.length;
  35.   //把staleSlot的value置为空，然后数组元素置为空
  36.   tab[staleSlot].value = null;
  37.   tab[staleSlot] = null;
  38.   size--; //元素个数-1
  40.   // Rehash until we encounter null
  41.   Entry e;
  42.   int i;
  43.   for (i = nextIndex(staleSlot, len);
  44.        (e = tab[i]) != null;
  45.        i = nextIndex(i, len)) {
  46.     ThreadLocal<?> k = e.get();
  47.     //k 为null代表引用对象被GC回收掉了
  48.     if (k == null) {
  49.       e.value = null;
  50.       tab[i] = null;
  51.       size--;
  52.     } else {
  53.       //因为元素个数减少了，就把后面的元素重新hash
  54.       int h = k.threadLocalHashCode & (len - 1);
  55.       //hash地址不相等，就代表这个元素之前发生过hash冲突(本来应该放在这没放在这)，
  56.       //现在因为有元素被移除了，很有可能原来冲突的位置空出来了，重试一次
  57.       if (h != i) {
  58.         tab[i] = null;
  60.         //继续采用链地址法存放元素
  61.         while (tab[h] != null)
  62.           h = nextIndex(h, len);
  63.         tab[h] = e;
  64.       }
  65.     }
  66.   }
  67.   return i;
  68. }

参考：https://mp.weixin.qq.com/s/JUb2GR4CmokO0SklFeNmwg