JUC-ThreadLocal篇

ThreadLocal

1.ThreadLocal简介

是什么？

​ ThreadLocal提供线程局部变量。这些变量与正常的变量不同，因为每一个线程在访问ThreadLocal实例的时候（通过其get或set方法）都有自己的、独立初始化的变量副本。ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户ID或事务ID）与线程关联起来。

能干嘛？

​ 实现每一个线程都有自己专属的本地变量副本(自己用自己的变量不麻烦别人，不和其他人共享，人人有份，人各一份)，主要解决了让每个线程绑定自己的值，通过使用get()和set()方法，获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全问题。

API介绍

//T get () 
Returns the value in the current thread's copy of this thread-local variable.

//protected T initialValue () 
Returns the current thread's "initial value" for this thread-local variable.

//void remove ( )
Removes the current thread's value for this thread-local variable.

//void set(T value)
Sets the current thread's copy of this thread-local variable to the specified value.

//static <S>  ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
Creates a thread local variable.

2.ThreadLocal案例

synchronized 三个售票员卖完50张票务，总量完成即可

class TicketDemo{

    int num = 50;

    public synchronized void saleTicket(){
        if(num>0){
            System.out.println(Thread.currentThread().getName()+"号售票员卖出第："+(num--));
        }else{
            System.out.println("=========卖完了=========");
        }
    }

}
public class ThreadLocalDemo1 {

    public static void main(String[] args) {
        TicketDemo ticket = new TicketDemo();

        for (int i = 1; i <=3 ; i++) {
            new Thread(()->{
                for (int j = 0; j <20; j++) {
                    ticket.saleTicket();
                    try {
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } , String.valueOf(i)).start();
        }
    }

}

ThreadLocal 卖房子不参加总和计算，希望销售各自为政，各凭销售本事提成，按照出单数各自统计

class House{

    //初始值为 0
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void saleHouse(){
        Integer value = threadLocal.get();
        value++;
        threadLocal.set(value);
    }

}
public class ThreadLocalDemo2 {

    public static void main(String[] args) {

        House house = new House();

        new Thread(() -> {
            try {
                for (int i = 1; i <=3; i++) {
                    house.saleHouse();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"---"+house.threadLocal.get());
            }finally {
                house.threadLocal.remove();//如果不清理自定义的 ThreadLocal 变量，可能会影响后续业务逻辑和造成内存泄露等问题
            }
        },"1号销售").start();

        new Thread(() -> {
            try {
                for (int i = 1; i <=2; i++) {
                    house.saleHouse();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"---"+house.threadLocal.get());
            }finally {
                house.threadLocal.remove();
            }
        },"2号销售").start();

        new Thread(() -> {
            try {
                for (int i = 1; i <=5; i++) {
                    house.saleHouse();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"---"+house.threadLocal.get());
            }finally {
                house.threadLocal.remove();
            }
        },"3号销售").start();


        //主线程  未参与售房
        System.out.println(Thread.currentThread().getName()+"\t"+"---"+house.threadLocal.get());
    }

}

总结：

1.因为每个 Thread 内有自己的实例副本且该副本只由当前线程自己使用。

2.既然其它 Thread 不可访问，那就不存在多线程间共享的问题。

3.统一设置初始值，但是每个线程对这个值的修改都是各自线程互相独立的。

如何才能不争抢？

1.加入synchronized或者Lock控制资源的访问顺序

2.人手一份，大家各自安好，没必要抢夺

3.ThreadLocal最佳实践

讨论非线程安全的SimpleDateFormat

官方的一段介绍
* Date formats are not synchronized.
* It is recommended to create separate format instances for each thread.
* If multiple threads access a format concurrently, it must be synchronized
* externally.    
    
翻译一下
//SimpleDateFormat中的日期格式不是同步的。
//推荐（建议）为每个线程创建独立的格式实例。如果多个线程同时访问一个格式，则它必须保持外部同步。    

​ SimpleDateFormat类内部有一个Calendar对象引用,它用来储存和这个SimpleDateFormat相关的日期信息,例如sdf.parse(dateStr),sdf.format(date) 诸如此类的方法参数传入的日期相关String,Date等等, 都是交由Calendar引用来储存的.这样就会导致一个问题如果你的SimpleDateFormat是个static的, 那么多个thread 之间就会共享这个SimpleDateFormat, 同时也是共享这个Calendar引用

public class DateUtils {

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

    /**
     * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
     * @param string
     * @return
     * @throws Exception
     */
    public static Date parseDate(String string)throws Exception {
        return sdf.parse(string);
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                try {
                    System.out.println(DateUtils.parseDate("2022-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

解决方案一

将SimpleDateFormat定义成局部变量。

public class DateUtils {

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

    /**
     * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
     * @param string
     * @return
     * @throws Exception
     */
    public static Date parseDate(String string)throws Exception {
        return sdf.parse(string);
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                try {
                    //方式一：将SimpleDateFormat定义成局部变量。
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    System.out.println(sdf.parse("2020-11-11 11:11:11"));
                    sdf = null;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

缺点：每调用一次方法就会创建一个SimpleDateFormat对象，方法结束又要作为垃圾回收。

解决方案二

采用静态同步方法

public class SynDateUtils {

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

    /**
     * 方式二：采用同步方法synchronized
     * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
     * @param string
     * @return
     * @throws Exception
     */
    public static synchronized Date parseDate(String string)throws Exception {
        return sdf.parse(string);
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                try {
                    System.out.println(SynDateUtils.parseDate("2022-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

解决方案三

ThreadLocal，也叫做线程本地变量或者线程本地存储。

public class ThreadLocalDateUtils {
    private static final ThreadLocal<SimpleDateFormat>  sdf_threadLocal =
            ThreadLocal.withInitial(()-> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

    /**
     * ThreadLocal可以确保每个线程都可以得到各自单独的一个SimpleDateFormat的对象，那么自然也就不存在竞争问题了。
     * @param string
     * @return
     * @throws Exception
     */
    public static Date parseDateTL(String string)throws Exception{
        return sdf_threadLocal.get().parse(string);
    }

    public static void main(String[] args) throws Exception{
        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                try {
                    System.out.println(ThreadLocalDateUtils.parseDateTL("2020-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    sdf_threadLocal.remove();
                }
            },String.valueOf(i)).start();
        }
    }
}

ThreadLocal可以确保每个线程都可以得到各自单独的一个SimpleDateFormat的对象，那么自然也就不存在竞争问题了。

解决方案四

使用线程安全的时间类DateTimeFormatter。

JDK8中，可以使用LocalDateTime代替 Calendar ， DateTimeFormatter代替 SimpleDateFormat

官方给出的解释: simple beautiful strong immutable thread-safe。

public class DateTimeFormatterUtils {

    public static final DateTimeFormatter sdf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    public static String format(LocalDateTime localDateTime){
        return sdf.format(localDateTime);
    }

    public static LocalDateTime parse(String string){
        return LocalDateTime.parse(string , sdf);
    }

    public static void main(String[] args) throws Exception {
        for (int i = 1; i <=5; i++) {
            new Thread(() -> {
                try {
                    System.out.println(DateTimeFormatterUtils.parse("2022-11-11 11:11:11"));
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

4.Thread，ThreadLocal，ThreadLocalMap 关系

Thread类

public class Thread implements Runnable {
    /* ThreadLocal values pertaining to this thread. This map is maintained
     * by the ThreadLocal class. */
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

ThreadLocal类

public class ThreadLocal<T> {
    
    static class ThreadLocalMap {
        
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        
    }
    
}

​ ThreadLocalMap实际上就是一个以ThreadLocal实例为key，任意对象为value的Entry对象。
当我们为ThreadLocal变量赋值，实际上就是以当前ThreadLocal实例为key，值为value的Entry往这个ThreadLocalMap中存放。

​ JVM内部维护了一个线程版的Map<Thread,T>(通过ThreadLocal对象的set方法，结果把ThreadLocal对象自己当做key，放进了ThreadLocalMap中)，每个线程要用到这个T的时候，用当前的线程去Map里面获取，通过这样让每个线程都拥有了自己独立的变量，人手一份，竞争条件被彻底消除，在并发模式下是绝对安全的变量。

5.ThreadLocal内存泄露问题

5.1 什么是内存泄漏

不再会被使用的对象或者变量占用的内存不能被回收，就是内存泄露。

5.2 强引用、软引用、弱引用、虚引用的区别

1、强引用（StrongReference）
最普遍的一种引用方式，如String s = new String (“abc”)，变量s就是字符串“abc”的强引用，只要还有强引用指向一个对象，就能表明对象还活着，垃圾回收不回收这种对象。如果要对强引用进行垃圾回收，需要设置强引用对象为 null ，即 s = null ， 或者让其超出对象的生命周期范围，则认为该对象不存在引用。

2、软引用（SoftReference）
用于描述还有用但非必须的对象，如果内存足够，不回收，如果内存不足，则回收。一般用于实现内存敏感的高速缓存，软引用可以和引用队列ReferenceQueue联合使用，如果软引用的对象被垃圾回收，JVM就会把这个软引用加入到与之关联的引用队列中。

3、弱引用（WeakReference）
弱引用和软引用大致相同，弱引用与软引用的区别在于 ：弱引用拥有更短暂的生命周期，不管内存够不够，都会回收，都会回收它的内存。

在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。短时间内通过弱引用取对应的数据，可以取到，当执行过第二次垃圾回收时，将返回null。弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。

4、虚引用（PhantomReference）
就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。
虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

5.3 Thread，ThreadLocal，ThreadLocalMap 关系

1.每个Thread对象维护着一个ThreadLocalMap的引用

2.ThreadLocalMap是ThreadLocal的内部类，用Entry来进行存储

3.调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值Value是传递进来的对象

4.调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象

5.ThreadLocal本身并不存储值，它只是自己作为一个key来让线程从ThreadLocalMap获取value，正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响

5.4 Entry为什么要用弱引用

当function01方法执行完毕后，栈帧销毁强引用 tl 也就没有了。但此时线程的ThreadLocalMap里某个Entry的key引用还指向这个对象。

若这个Key引用是强引用，就会导致key指向的ThreadLocal对象及V指向的对象不能被GC回收，造成内存泄漏；

若这个key引用是弱引用，就大概率会减少内存泄漏的问题(还有一个key为null的雷)。使用弱引用，就可以使ThreadLocal对象在方法执行完毕后顺利被回收且Entry的key引用指向为null。

1.当我们为ThreadLocal变量赋值，实际上就是当前的Entry (ThreadLocal实例为key，值为value)往这个ThreadLocalMap中存放。

Entry中的key是弱引用，当ThreadLocal外部强引用被置为null (tl=null) , 那么系统 GC 的时候，根据可达性分析，这个ThreadLocal实例就没有任何一条链路能够引用到它，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现Key为null的Entry，就没有办法访问这些Key为null的Entry的value，如果当前线程再迟迟不结束的话，这些Key为null的Entry的Value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

2.当然，如果当前Thread运行结束，ThreadLocal，ThreadLocalMap, Entry没有引用链可达，在垃圾回收的时候都会被系统进行回收。

3.但在实际使用中我们有时候会用线程池去维护我们的线程，比如在Executors.newFixedThreadPool()时创建线程的时候，为了复用线程是不会结束的，所以ThreadLocal内存泄漏就值得我们小心。

5.5 解决ThreadLocal内存泄露问题

​ ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用引用他，那么系统GC的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话(比如正好用在线程池)，这些key为null的Entry的value就会一直存在一条强引用链。Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

​ 虽然弱引用，保证了key指向的ThreadLocal对象能被及时回收，但是v指向的value对象是需要ThreadLocalMap调用get、set时发现key为null时才会去回收整个entry、value，因此弱引用不能100%保证内存不泄露。

​ 我们要在不使用某个ThreadLocal对象后，手动调用remove()方法来删除它，尤其是在线程池中，不仅仅是内存泄露的问题，因为线程池中的线程是重复使用的，意味着这个线程的ThreadLocalMap对象也是重复使用的，如果我们不手动调用remove方法，那么后面的线程就有可能获取到上个线程遗留下来的value值，造成bug。

​ 从set,getEntry,remove方法看出，在ThreadLocal的生命周期里，针对ThreadLocal存在的内存泄漏的问题，都会通过expungeStaleEntry，cleanSomeSlots, replaceStaleEntry这三个方法清理掉key为null的脏entry。

6.总结

1.ThreadLocal 并不解决线程间共享数据的问题

2.ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景

3.ThreadLocal 通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题

4.每个线程持有一个只属于自己的专属Map并维护了ThreadLocal对象与具体实例的映射，该Map由于只被持有它的线程访问，故不存在线程安全以及锁的问题

5.ThreadLocalMap的Entry对ThreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题

key来让线程从ThreadLocalMap获取value，正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响

5.4 Entry为什么要用弱引用

当function01方法执行完毕后，栈帧销毁强引用 tl 也就没有了。但此时线程的ThreadLocalMap里某个Entry的key引用还指向这个对象。

若这个Key引用是强引用，就会导致key指向的ThreadLocal对象及V指向的对象不能被GC回收，造成内存泄漏；

若这个key引用是弱引用，就大概率会减少内存泄漏的问题(还有一个key为null的雷)。使用弱引用，就可以使ThreadLocal对象在方法执行完毕后顺利被回收且Entry的key引用指向为null。

[外链图片转存中…(img-b3R2R5Si-1698561182946)]

1.当我们为ThreadLocal变量赋值，实际上就是当前的Entry (ThreadLocal实例为key，值为value)往这个ThreadLocalMap中存放。

Entry中的key是弱引用，当ThreadLocal外部强引用被置为null (tl=null) , 那么系统 GC 的时候，根据可达性分析，这个ThreadLocal实例就没有任何一条链路能够引用到它，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现Key为null的Entry，就没有办法访问这些Key为null的Entry的value，如果当前线程再迟迟不结束的话，这些Key为null的Entry的Value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

2.当然，如果当前Thread运行结束，ThreadLocal，ThreadLocalMap, Entry没有引用链可达，在垃圾回收的时候都会被系统进行回收。

3.但在实际使用中我们有时候会用线程池去维护我们的线程，比如在Executors.newFixedThreadPool()时创建线程的时候，为了复用线程是不会结束的，所以ThreadLocal内存泄漏就值得我们小心。

5.5 解决ThreadLocal内存泄露问题

​ ThreadLocalMap使用ThreadLocal的弱引用作为key，如果一个ThreadLocal没有外部强引用引用他，那么系统GC的时候，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会出现key为null的Entry，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话(比如正好用在线程池)，这些key为null的Entry的value就会一直存在一条强引用链。Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成内存泄漏。

​ 虽然弱引用，保证了key指向的ThreadLocal对象能被及时回收，但是v指向的value对象是需要ThreadLocalMap调用get、set时发现key为null时才会去回收整个entry、value，因此弱引用不能100%保证内存不泄露。

​ 我们要在不使用某个ThreadLocal对象后，手动调用remove()方法来删除它，尤其是在线程池中，不仅仅是内存泄露的问题，因为线程池中的线程是重复使用的，意味着这个线程的ThreadLocalMap对象也是重复使用的，如果我们不手动调用remove方法，那么后面的线程就有可能获取到上个线程遗留下来的value值，造成bug。

​ 从set,getEntry,remove方法看出，在ThreadLocal的生命周期里，针对ThreadLocal存在的内存泄漏的问题，都会通过expungeStaleEntry，cleanSomeSlots, replaceStaleEntry这三个方法清理掉key为null的脏entry。

6.总结

1.ThreadLocal 并不解决线程间共享数据的问题

2.ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景

3.ThreadLocal 通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题

4.每个线程持有一个只属于自己的专属Map并维护了ThreadLocal对象与具体实例的映射，该Map由于只被持有它的线程访问，故不存在线程安全以及锁的问题

5.ThreadLocalMap的Entry对ThreadLocal的引用为弱引用，避免了ThreadLocal对象无法被回收的问题

6.都会通过expungeStaleEntry，cleanSomeSlots, replaceStaleEntry这三个方法回收键为 null 的 Entry 对象的值（即为具体实例）以及 Entry 对象本身从而防止内存泄漏，属于安全加固的方法