【JUC】 ThreadLocal原理+内存泄漏问题

ThreadLocal

ThreadLocal是一个线程内部的存储器，存放的元素只能线程自身访问，其余线程访问不了。

与Synchronized的比较

Synchronized，是依赖与锁机制，在并发情况下，只让一个线程访问共享的变量或者代码块。而ThreadLocal则是为每个线程提供一个变量的副本，使得每个线程在访问的时候访问的都不是同一个对象。

应用场景

1. 每个线程都要有一个独享的对象，通常是一个工具类。SimpleDateFormat、Random

   需求：10个线程打印1000个时间，由一个SimpleDateFormat获取到的时间。肯定会出问题，并发问题，时间会重复。怎么解决呢，加锁或者给每个线程一个SimpleDateFormat对象。线程都调用自己的那一个。加锁也能实现，但是必然时间会满下来。一个一个获取锁然后释放锁。而ThreadLocal则是空间换时间。

   例子，笔记本做笔记。10个人用一个，会有问题。但是10个人每人都复印一个，都有自己的就没问题

   package study;
   
   import java.text.SimpleDateFormat;
   import java.util.Date;
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   public class ThreadLocalDemo {
   
       public static ExecutorService es = Executors.newFixedThreadPool(10);
       
       public static void main(String[] args) {
           for (int i = 0; i < 1000; i++) {
               int finalI = i;
               es.submit(()->{
                   System.out.println(ThreadLocald.dateFormatThreadLocal.get().format(new Date(1000 * finalI)));
               });
           }
   
       }
   }
   class ThreadLocald{
       public static ThreadLocal<SimpleDateFormat> dateFormatThreadLocal =
               ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"));
   }
   

2. 每个线程保存全局变量，比如拦截器获取用户信息，一个请求携带用户token。拦截器中解析成用户信息。然后这个请求会调用不同的方法，可以使用参数传递。但是每个都要传递。繁琐了。可以使用ThreadLocal。

   使用set方法。而不是重写initialValue方法。

   区别：

   ​ initialValue是初始化的时候已经知道要什么对象了。工具类这些

   ​ set 则是不由ThreadLocal了，而是代码流程什么时候执行到，再创建对象set进去

原理

Thread、ThreadLoacl、ThreadLoclMap关系

一个Thread有一个ThreadLocalMap，一个ThreadLocalMap会有很多个ThreadLocal。

也就是一个线程对应很多个ThreadLocal。

重要方法源码

1. initialVal() 这个方法只会调用一次，因为代码逻辑，先是判断能不能获取到，获取到了就不会再次setInitialValue。除非你给remove()掉。

   //需要重写。
   protected T initialValue() {
       return null;
   }
   

   延迟调用，不会显示调用initialVal，而是在get()时候调用

   public T get() {
           Thread t = Thread.currentThread();
           ThreadLocalMap map = getMap(t);//获取当前线程的ThreadLocalMap
           if (map != null) {
               ThreadLocalMap.Entry e = map.getEntry(this);//以ThreadLocal为key获取value，就是存在里面的对象。k-v形式
               if (e != null) {
                   @SuppressWarnings("unchecked")
                   T result = (T)e.value;
                   return result;//返回获取到的结果
               }
           }
           return setInitialValue();//第一次肯定上面为null，会执行到这里
       }
   

   private T setInitialValue() {
       T value = initialValue();//调用了重写的方法，返回一个初始对象
       Thread t = Thread.currentThread();
       ThreadLocalMap map = getMap(t);
       if (map != null)
           map.set(this, value);
       else
           createMap(t, value);//创建一个ThreadLocalMap
       return value;
   }
     void createMap(Thread t, T firstValue) {
           t.threadLocals = new ThreadLocalMap(this, firstValue);
       }
   

2. set()

   //直接就是 setInitialValue()的流程。
   public void set(T value) {
           Thread t = Thread.currentThread();
           ThreadLocalMap map = getMap(t);
           if (map != null)
               map.set(this, value);
           else
               createMap(t, value);
       }
   

ThreadLoclMap

ThreadLoacl内部类

private Entry[] table;
 Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
 }
底层就是使用Entry[]数组，装一个对象Entry。这个对象有俩属性，ThreadLocal 和 Object 作为 key 和 value。 
和HashMap实现差不多。
但是处理hash冲突则不和HashMap一样。它使用的是线性探测法，
初始大小为16 负载因子为1 即满了才扩。一次扩二倍

问题，内存泄漏

内存泄漏：对象不再有用，但是不能被正常回收，内存就被占用

怎么造成的

 Entry(ThreadLocal<?> k, Object v) {
                super(k);// WeakReference<ThreadLocal<?>> 标记为弱引用，GC会回收
                value = v;//强引用，GC不会回收
}

要是Thread停止了，那么还会会释放这个线程所占所有内存，包括ThreadLocalMap，所以不会有问题。

但是，在线程池中，一个线程是会一直存在的。被复用。所以就无法释放，key可以自己释放，但是value不能被释放。随着ThreadLocal越来越多就OOM了

且假设在业务代码中使用完 ThreadLocal, ThreadLocal ref 被回收了。由于 threadLocalMap 只持有 ThreadLocal 的弱引用，没有任何强引用指向 threadlocal 实例（这里 Entry 不再强引用 ThreadLocal了）, 所以 threadlocal 就可以顺利被 gc 回收, 此时 Entry 中的 key = null。在没有手动删除 Entry 以及 CurrentThread 依然运行的前提下，也存在始终有强引用链 CurrentThread Ref → CurrentThread →Map(ThreadLocalMap)-> entry。

所以，value 就不会被回收，而这块 value 永远不会被访问到了（因为key=null）, 导致value内存泄漏。

JDK知道有内存泄漏问题，所以调用remove，set，rehash都会去检查有没有强引用未释放.所以阿里规约要求使用完毕ThreadLocal必须手动remvoe()

ThreadLocal<?> k = e.get();
if (k == null) {
    e.value = null; // Help the GC
} 

问题：创建子线程时，子线程是得不到父线程的 ThreadLocal，有什么办法可以解决这个问题？

答：可以使用 InheritableThreadLocal 来代替 ThreadLocal，ThreadLocal 和 InheritableThreadLocal 都是线程的属性，所以可以做到线程之间的数据隔离，在多线程环境下我们经常使用，但在有子线程被创建的情况下，父线程 ThreadLocal 是无法传递给子线程的，但 InheritableThreadLocal 可以，主要是因为在线程创建的过程中，会把InheritableThreadLocal 里面的所有值传递给子线程

强引用：只要强引用还在，该引用指向的实例对象就永远不会被回收  Object value = v; 就是强引用
弱引用：弱引用指向的对象只能存活到GC之前，需要继承 WeakReference
软引用：软引用指向的对象会在内存不足的时候被回收

至于此，想一下为什么key要是弱引用？

key为强引用，ThreadLocalMap和Thread生命周期一样长，所以key也和value一样，不删除就不会释放

key为弱引用，GC回收会把key回收，置为null。但是也是有一层保险，在set，get，rehash时候就会判断key是不是null，然后将value置为null。

总结

• JVM 利用设置 ThreadLocalMap 的 Key 为弱引用，来避免内存泄露。
• JVM 利用调用 remove、get、set 方法的时候，回收弱引用。
• 当 ThreadLocal 存储很多 Key 为 null 的 Entry 的时候，而不再去调用 remove、 get、set 方法，那么将导致内存泄漏。
• 使用线程池+ ThreadLocal 时要小心，因为这种情况下，线程是一直在不断的重复运行的，从而也就造成了 value 可能造成累积的情况。

ThreadLocal 是线程内部的数据存储类，每个线程中都会保存一个ThreadLocal.ThreadLocalMap threadLocals = null;，ThreadLocalMap 是 ThreadLocal 的静态内部类，里面保存了一个 private Entry[] table 数组，这个数组就是用来保存 ThreadLocal 中的值。通过这种方式，就能让我们在多个线程中互不干扰地存储和修改数据。

---

增加内容：上面太不简洁了
更新一下内存泄漏的内容
内存泄漏：是指内存中的某个对象无法被回收，还没用。
ThreadLocl内存泄漏：
首先是引用链说明：
Thread – ThreadLocalMap – Entry --(key – ThreadLcal, val – value）

此刻状态为，线程存在于线程池中，一直不被释放。而ThreadLocal又无用了。

此刻假设 key为强引用，那么ThreadLocal无法被释放，且无用，就是内存泄漏。所以设置为弱引用。只要ThreadLcal无用了，就下一次GC回收。

再考虑Entry的存在，也是一个无用，且无法释放。并且key为null了，也无法获取。内存泄漏。
解决是：设计者当然知道会出现这种情况，所以在多个地方都做了清理无用 Entry ，即 key 已经被回收的 Entry 的操作。比如get()查找key 为null那么就将value == null , tab[i] == null 。扩容、删除都会判断。

最佳选择：用完threadlocal之后 调用remove方法。