Java——ThreadLocal概述、解决SimpleDateFormat出现的异常、内存泄漏、弱引用、remove方法

转x33g5p2x  于2022-06-06 转载在 Java  
字(11.4k)|赞(0)|评价(0)|浏览(524)

①. ThreadLocal简介

①. ThreadLocal是什么

①. ThreadLocal本地线程变量,线程自带的变量副本(实现了每一个线程副本都有一个专属的本地变量,主要解决的就是让每一个线程绑定自己的值,自己用自己的,不跟别人争抢。通过使用get()和set()方法,获取默认值或将其值更改为当前线程所存的副本的值从而避免了线程安全的问题)
②. synchronized或者lock,有个管理员,好比,现在大家签到,多个同学(线程),但是只有一只笔,只能同一个时间,只有一个线程(同学)签到,加锁(同步机制是以时间换空间,执行时间不一样,类似于排队)

③. ThreadLocal,人人有份,每个同学手上都有一支笔,自己用自己的,不用再加锁来维持秩序(同步机制是以空间换时间,为每一个线程都提供了一份变量的副本,从而实现同时访问,互不干扰同时访问,肯定效率高啊)

②. api介绍

  • ①. protected T initialValue?():initialValue():返回此线程局部变量的当前线程的"初始值"
    (对于initialValue()较为老旧,jdk1.8又加入了withInitial()方法)
  • ②. static ThreadLocal withInitial?(Supplier supplier):创建线程局部变量
  • ③. T get?():返回当前线程的此线程局部变量的副本中的值
  • ④. void set?(T value):将当前线程的此线程局部变量的副本设置为指定的值
  • ⑤. void remove?():删除此线程局部变量的当前线程的值

③. 永远的helloword

  1. /***
  2.  * 看每个销售员可以出售多少套房子
  3.  */
  4. class House{
  5.     /**
  6.      initialValue():返回此线程局部变量的当前线程的"初始值"
  7.      对于initialValue()较为老旧,jdk1.8又加入了withInitial()方法
  8.      ThreadLocal<Integer>threadLocal=new ThreadLocal<Integer>() {
  9.          @Override
  10.          protected Integer initialValue() {
  11.              return 0;
  12.          }
  13.      };*/
  14.     //public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier)
  15.     //withInitial(Supplier<? extends S> supplier):创建线程局部变量
  16.     //ThreadLocal本地线程变量,线程自带的变量副本
  17.     ThreadLocal<Integer>threadLocal=
  18.             ThreadLocal.withInitial(()->0);
  20.     public void saleHouse(){
  21.         //T get():返回当前线程的此线程局部变量的副本中的值。
  22.         Integer value = threadLocal.get();
  23.         value++;
  24.         //void set(T value):将当前线程的此线程局部变量的副本设置为指定的值。
  25.         threadLocal.set(value);
  26.     }
  27. }
  28. public class ThreadLocalDemo {
  29.     public static void main(String[] args) {
  30.         House house = new House();
  31.         new Thread(()->{
  32.             try{
  33.                 for (int i = 1; i <=3; i++) {
  34.                     house.saleHouse();
  35.                 }
  36.                 System.out.println(Thread.currentThread().getName()+"\t"+"卖出:"+house.threadLocal.get());
  37.             }catch (Exception e){
  38.                 e.getStackTrace();
  39.             }finally {
  40.                 //void remove():删除此线程局部变量的当前线程的值
  41.                 //在阿里巴巴手册中有说明,尽量在代理中使用try-finally块进行回收
  42.                 house.threadLocal.remove();
  43.                 //下面获取到的值是线程的初始值0
  44.                 System.out.println("**********"+house.threadLocal.get());
  45.             }
  46.         },"t1").start();
  48.         new Thread(()->{
  49.             try{
  50.                 for (int i = 1; i <=5; i++) {
  51.                     house.saleHouse();
  52.                 }
  53.                 System.out.println(Thread.currentThread().getName()+"\t"+"卖出:"+house.threadLocal.get());
  54.             }catch (Exception e){
  55.                 e.getStackTrace();
  56.             }finally {
  57.                 house.threadLocal.remove();
  58.             }
  59.         },"t2").start();
  61.         new Thread(()->{
  62.             try{
  63.                 for (int i = 1; i <=8; i++) {
  64.                     house.saleHouse();
  65.                 }
  66.                 System.out.println(Thread.currentThread().getName()+"\t"+"卖出:"+house.threadLocal.get());
  67.             }catch (Exception e){
  68.                 e.getStackTrace();
  69.             }finally {
  70.                 house.threadLocal.remove();
  71.             }
  72.         },"t3").start();
  73.         System.out.println(Thread.currentThread().getName()+"\t"+"卖出了:"+house.threadLocal.get());
  74.     }
  75. }
  76. /**
  77.  * t1	卖出:3
  78.  * t2	卖出:5
  79.  * **********0
  80.  * main	卖出了:0
  81.  * t3	卖出:8
  82.  * */

④. 通过上面代码总结

  • ①. 因为每个Thread内有自己的实例副本且该副本只由当前线程自己使用
  • ②. 既然其他Thread不可访问,那就不存在多线程共享的问题
  • ③. 统一设置初始值,但是每个线程对这个值的修改都是各自线程互相独立的
  • ④. 加入synchronized或者lock控制线程的访问顺序,而ThreadLocal人手一份,大家各自安好,没必要抢夺

②. 从阿里ThreadLocal规范开始

①. 公司业务:在对一些业务日志写入数据库的时候,日期调用了sdf的静态,导致了会报错或者日期乱了(生产故障)

①. 非线程安全的SimpleDateFormat

  • ①. 写时间工具类,一般写成静态的成员变量,不知,此种写法的多线程下的危险性！
  • ②. 代码展示
  1. public class DateUtils
  2. {
  3.     public static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  4.     /**
  5.      * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
  6.      * @param stringDate
  7.      * @return
  8.      * @throws Exception
  9.      */
  10.     public static Date parseDate(String stringDate)throws Exception
  11.     {
  12.         return sdf.parse(stringDate);
  13.     }
  14.     
  15.     public static void main(String[] args) throws Exception
  16.     {
  17.         for (int i = 1; i <=30; i++) {
  18.             new Thread(() -> {
  19.                 try {
  20.                     System.out.println(DateUtils.parseDate("2020-11-11 11:11:11"));
  21.                 } catch (Exception e) {
  22.                     e.printStackTrace();
  23.                 }
  24.             },String.valueOf(i)).start();
  25.         }
  26.     }
  27. }
  • ③. bug

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

②. 将SimpleDateFormat定义成局部变量(方案一)

  • 缺点:每调用一次方法就会创建一个SimpleDateFormat对象,方法结束又要作为垃圾回收
  1. public class DateUtils
  2. {
  3.     public static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  4.     /**
  5.      * 模拟并发环境下使用SimpleDateFormat的parse方法将字符串转换成Date对象
  6.      * @param stringDate
  7.      * @return
  8.      * @throws Exception
  9.      */
  10.     public static Date parseDate(String stringDate)throws Exception
  11.     {
  12.         return sdf.parse(stringDate);
  13.     }
  15.     public static void main(String[] args) throws Exception
  16.     {
  17.         for (int i = 1; i <=30; i++) {
  18.             new Thread(() -> {
  19.                 try {
  20.                     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  21.                     System.out.println(sdf.parse("2020-11-11 11:11:11"));
  22.                     sdf = null;
  23.                 } catch (Exception e) {
  24.                     e.printStackTrace();
  25.                 }
  26.             },String.valueOf(i)).start();
  27.         }
  28.     }

③. ThreadLocal 解决日期格式乱码问题

  1. /**
  2.  * 在对一些业务日志写入数据库的时候,日期调用了sdf的静态,导致了会报错或者日期乱了
  3.  * */
  4. public class ThreadLocalDataUtils {
  6.     public static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  8.     /**
  9.      解决方案一:加入synchronized,用时间换空间,效率低
  10.     */
  11.     /**
  12.      如果不加会导致线程安全问题,SimpleDateFormat类内部有一个Calendar对象引用,
  13.      SimpleDateFormat相关的日期信息,例如sdf.parse(dateStr),sdf.format(date)
  14.      诸如此类的方法参数传入的日期相关String,Date等等, 都是交由Calendar引用来储存的.
  15.      这样就会导致一个问题如果你的SimpleDateFormat是个static的,那么多个thread之间
  16.      就会共享这个SimpleDateFormat,同时也是共享这个Calendar引用(相当于买票案列)
  17.     */
  18.     //public static synchronized Date parse(String stringDate) throws ParseException {
  19.     public static  Date parse(String stringDate) throws ParseException {
  20.         System.out.println(sdf.parse(stringDate));
  21.         return sdf.parse(stringDate);
  22.     }
  24.     /***
  25.      * 解决方案二:使用ThreadLocal,用空间换时间,效率高
  26.      * ThreadLocal中变量副本会人手一份,每次使用完了threadLocal后都要将资源进行释放的处理
  27.      */
  28.     public static final ThreadLocal<SimpleDateFormat>sdfThreadLocal=
  29.             ThreadLocal.withInitial(()->new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
  30.     public static  Date parseByThreadLocal(String stringDate) throws ParseException {
  31.         return sdfThreadLocal.get().parse(stringDate);
  32.     }
  33.     //3 DateTimeFormatter 代替 SimpleDateFormat
  34.     public static final DateTimeFormatter DATE_TIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  36.     public static String formatForDateTime(LocalDateTime localDateTime) {
  37.         return DATE_TIME_FORMAT.format(localDateTime);
  38.     }
  40.     public static LocalDateTime parseForDateTime(String dateString) {
  41.         return LocalDateTime.parse(dateString,DATE_TIME_FORMAT);
  42.     }
  44.     public static void main(String[] args) throws Exception{
  45.         for (int i = 1; i <=3; i++) {
  46.             new Thread(()->{
  47.                 try {
  48.                    //ThreadLocalDataUtils.parse("2021-03-30 11:20:30");
  49.                    //System.out.println(ThreadLocalDataUtils.parseByThreadLocal("2021-03-30 11:20:30"));
  50.                    System.out.println(ThreadLocalDataUtils.parseForDateTime("2021-03-30 11:20:30"));
  51.                    // System.out.println(ThreadLocalDataUtils.formatForDateTime(LocalDateTime.now()));
  52.                 } catch (Exception e) {
  53.                     e.printStackTrace();
  54.                 }finally {
  55.                     ThreadLocalDataUtils.sdfThreadLocal.remove();
  56.                 }
  57.             },String.valueOf(i)).start();
  58.         }
  59.     }
  60. }

④. 阿里规范怎么说的？

③. ThreadLocal源码分析

①. Thread|ThreadLocal|ThreadLocalMap关系

①. Thread和ThreadLocal

②. ThreadLocal和ThreadLocalMap

③. All三者总概括

  1. Thread类中有一个ThreadLocal.ThreadLocalMap threadLocals = null的变量,这个ThreadLocal相当于是Thread类和ThreadLocalMap的桥梁,在ThreadLocal中有静态内部类ThreadLocalMap,ThreadLocalMap中有Entry数组
  2. 当我们为threadLocal变量赋值,实际上就是以当前threadLocal实例为key,值为value的Entry往这个threadLocalMap中存放
  3. t.threadLocals = new ThreadLocalMap(this, firstValue) 如下这行代码,可以知道每个线程都会创建一个ThreadLocalMap对象,每个线程都有自己的变量副本

  1. //核心代码说明
  2. public void set(T value) {
  3.     Thread t = Thread.currentThread();
  4.     ThreadLocalMap map = getMap(t);
  5.     if (map != null)
  6.         map.set(this, value);
  7.     else
  8.         createMap(t, value);
  9. }
  10. void createMap(Thread t, T firstValue) {
  11.    t.threadLocals = new ThreadLocalMap(this, firstValue);
  12. }
  13. ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  14.     table = new Entry[INITIAL_CAPACITY];
  15.     int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  16.     table[i] = new Entry(firstKey, firstValue);
  17.     size = 1;
  18.     setThreshold(INITIAL_CAPACITY);
  19. }

②. set方法详解

①. 首先获取当前线程,并根据当前线程获取一个Map
②. 如果获取的Map不为空,则将参数设置到Map中(当前ThreadLocal的引用作为key)
③. 如果Map为空,则给该线程创建 Map,并设置初始值

  1. /**
  2.      * 设置当前线程对应的ThreadLocal的值
  3.      *
  4.      * @param value 将要保存在当前线程对应的ThreadLocal的值
  5.      */
  6.     public void set(T value) {
  7.         // 获取当前线程对象
  8.         Thread t = Thread.currentThread();
  9.         // 获取此线程对象中维护的ThreadLocalMap对象
  10.         ThreadLocalMap map = getMap(t);
  11.         // 判断map是否存在
  12.         if (map != null)
  13.             // 存在则调用map.set设置此实体entry
  14.             map.set(this, value);
  15.         else
  16.             // 1)当前线程Thread 不存在ThreadLocalMap对象
  17.             // 2)则调用createMap进行ThreadLocalMap对象的初始化
  18.             // 3)并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
  19.             createMap(t, value);
  20.     }
  22.  /**
  23.      * 获取当前线程Thread对应维护的ThreadLocalMap 
  24.      * 
  25.      * @param  t the current thread 当前线程
  26.      * @return the map 对应维护的ThreadLocalMap 
  27.      */
  28.     ThreadLocalMap getMap(Thread t) {
  29.         return t.threadLocals;
  30.     }
  31. 	/**
  32.      *创建当前线程Thread对应维护的ThreadLocalMap 
  33.      *
  34.      * @param t 当前线程
  35.      * @param firstValue 存放到map中第一个entry的值
  36.      */
  37. 	void createMap(Thread t, T firstValue) {
  38.         //这里的this是调用此方法的threadLocal
  39.         t.threadLocals = new ThreadLocalMap(this, firstValue);
  40.     }
  41.     
  42. 	 /*
  43. 	  * firstKey : 本ThreadLocal实例(this)
  44. 	  * firstValue ： 要保存的线程本地变量
  45. 	  */
  46. 	ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
  47. 	        //初始化table
  48. 	        table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
  49. 	        //计算索引(重点代码)
  50. 	        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
  51. 	        //设置值
  52. 	        table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
  53. 	        size = 1;
  54. 	        //设置阈值
  55. 	        setThreshold(INITIAL_CAPACITY);
  56. 	    }

③. get方法详解

  • 先获取当前线程的ThreadLocalMap变量,如果存在则返回值,不存在则创建并返回初始值
  1. /**
  2.      * 返回当前线程中保存ThreadLocal的值
  3.      * 如果当前线程没有此ThreadLocal变量,
  4.      * 则它会通过调用{@link #initialValue} 方法进行初始化值
  5.      *
  6.      * @return 返回当前线程对应此ThreadLocal的值
  7.      */
  8.     public T get() {
  9.         // 获取当前线程对象
  10.         Thread t = Thread.currentThread();
  11.         // 获取此线程对象中维护的ThreadLocalMap对象
  12.         ThreadLocalMap map = getMap(t);
  13.         // 如果此map存在
  14.         if (map != null) {
  15.             // 以当前的ThreadLocal 为 key,调用getEntry获取对应的存储实体e
  16.             ThreadLocalMap.Entry e = map.getEntry(this);
  17.             // 对e进行判空 
  18.             if (e != null) {
  19.                 @SuppressWarnings("unchecked")
  20.                 // 获取存储实体 e 对应的 value值
  21.                 // 即为我们想要的当前线程对应此ThreadLocal的值
  22.                 T result = (T)e.value;
  23.                 return result;
  24.             }
  25.         }
  26.         /*
  27.         	初始化 : 有两种情况有执行当前代码
  28.         	第一种情况: map不存在,表示此线程没有维护的ThreadLocalMap对象
  29.         	第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
  30.          */
  31.         return setInitialValue();
  32.     }
  34.     /**
  35.      * 初始化
  36.      *
  37.      * @return the initial value 初始化后的值
  38.      */
  39.     private T setInitialValue() {
  40.         // 调用initialValue获取初始化的值
  41.         // 此方法可以被子类重写, 如果不重写默认返回null
  42.         T value = initialValue();
  43.         // 获取当前线程对象
  44.         Thread t = Thread.currentThread();
  45.         // 获取此线程对象中维护的ThreadLocalMap对象
  46.         ThreadLocalMap map = getMap(t);
  47.         // 判断map是否存在
  48.         if (map != null)
  49.             // 存在则调用map.set设置此实体entry
  50.             map.set(this, value);
  51.         else
  52.             // 1)当前线程Thread 不存在ThreadLocalMap对象
  53.             // 2)则调用createMap进行ThreadLocalMap对象的初始化
  54.             // 3)并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
  55.             createMap(t, value);
  56.         // 返回设置的值value
  57.         return value;

④. remove方法详解

①. 首先获取当前线程,并根据当前线程获取一个Map
②. 如果获取的Map不为空,则移除当前ThreadLocal对象对应的entry

  1. /**
  2.      * 删除当前线程中保存的ThreadLocal对应的实体entry
  3.      */
  4.      public void remove() {
  5.         // 获取当前线程对象中维护的ThreadLocalMap对象
  6.          ThreadLocalMap m = getMap(Thread.currentThread());
  7.         // 如果此map存在
  8.          if (m != null)
  9.             // 存在则调用map.remove
  10.             // 以当前ThreadLocal为key删除对应的实体entry
  11.              m.remove(this);
  12.      }

④. ThreadLocal内存泄漏问题

①. 为什么源代码用弱引用？

①. 当function01方法执行完毕后,栈帧销毁强引用 tl 也就没有了。但此时线程的ThreadLocalMap里某个entry的key引用还指向这个对象
②. 若这个key引用是强引用,就会导致key指向的ThreadLocal对象及v指向的对象不能被gc回收,造成内存泄漏
③. 若这个key引用是弱引用就大概率会减少内存泄漏的问题(还有一个key为null的雷)。使用弱引用,就可以使ThreadLocal对象在方法执行完毕后顺利被回收且Entry的key引用指向为null

②. key为null的entry,原理解析

  • ①. ThreadLocalMap使用ThreadLocal的弱引用作为key,如果一个ThreadLocal没有外部强引用引用他,那么系统gc的时候,这个ThreadLocal势必会被回收,这样一来,ThreadLocalMap中就会出现key为null的Entry,就没有办法访问这些key为null的Entry的value,如果当前线程再迟迟不结束的话(比如正好用在线程池),这些key为null的Entry的value就会一直存在一条强引用链
  • ②. 虽然弱引用,保证了key指向的ThreadLocal对象能被及时回收,但是v指向的value对象是需要ThreadLocalMap调用get、set时发现key为null时才会去回收整个entry、value
  • ③. 因此弱引用不能100%保证内存不泄露。我们要在不使用某个ThreadLocal对象后,手动调用remoev方法来删除它,尤其是在线程池中,不仅仅是内存泄露的问题,因为线程池中的线程是重复使用的,意味着这个线程的ThreadLocalMap对象也是重复使用的,如果我们不手动调用remove方法,那么后面的线程就有可能获取到上个线程遗留下来的value值,造成bug
  • ④. 如果当前thread运行结束,threadLocal,threadLocalMap, Entry没有引用链可达,在垃圾回收的时候都会被系统进行回收
  • ⑤. 但在实际使用中我们有时候会用线程池去维护我们的线程,比如在Executors.newFixedThreadPool()时创建线程的时候,为了复用线程是不会结束的,所以threadLocal内存泄漏就值得我们小心

  • ⑥. 出现内存泄漏的真实原因 (1). 没有手动删除这个Entry (2). CurrentThread依然运行

③. set、get方法会去检查所有键为null的Entry对象

①. set( )


②. get( )

③. remove( )

④. 结论(在finally后面调用remove方法)

⑤. ThreadLocal小总结

  • ①. ThreadLocal本地线程变量,以空间换时间,线程自带的变量副本,人手一份,避免了线程安全问题
  • ②. 每个线程持有一个只属于自己的专属Map并维护了Thread Local对象与具体实例的映射,该Map由于只被持有它的线程访问,故不存在线程安全以及锁的问题
  • ③. ThreadLocalMap的Entry对ThreadLocal的引用为弱引用,避免了ThreadLocal对象无法被回收的问题
  • ④. 都会通过expungeStaleEntry,cleanSomeSlots, replace StaleEntry这三个方法回收键为 null 的 Entry 对象的值(即为具体实例)以及 Entry 对象本身从而防止内存泄漏,属于安全加固的方法
  • ⑤. 用完之后一定要remove操作

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://lebron.blog.csdn.net/article/details/125114033

内容来源于网络，如有侵权，请联系作者删除！

Java开发语言java细节

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com