0
0

ThreadLocal原理 、什么是内存泄漏

文章目录

1、是什么

在Java的多线程并发执行过程中，为了保证多个线程对变量的安全访问，可以将变量放到

ThreadLocal

类型的对象中，使变量在每个线程中都有

独立值

，不会出现一个线程读取变量时被另一个线程修改的情况。

程序创建一个ThreadLocal实例，那么在访问这个变量的时候，每个线程都会有一个独立的 自己的 本地值，“线程本地变量”可以看成是专属于线程的变量，不受其他线程干扰。当线程结束时，每个线程所拥有的本地值也会被释放。在多线程并发操作“线程本地变量” 的时候，线程各自操纵的是自己的本地值，从而规避了线程安全问题

实现

每一个线程都有自己专属的本地变量副本

(自己用自己的变量不麻烦别人，不和其他人共享）

2、api介绍

在这里插入图片描述

假定一个场景：5个销售卖房子，集团高层只关心

销售总量

的准确统计数，按照总销售额统计，方便集团公司发奖金

  • 群雄逐鹿起纷争—为了数据安全只能加锁
classHouse{int saleCount =0;publicsynchronizedvoidsaleHouse(){++ saleCount;}}publicclassThreadLocalDemo{publicstaticvoidmain(String[] args){House house =newHouse();for(int i =1;i <=5;i ++){newThread(()->{int size =newRandom().nextInt(5)+1;System.out.println(size);for(int j =1;j <= size;j ++){
                    house.saleHouse();}},String.valueOf(i)).start();}try{TimeUnit.MILLISECONDS.sleep(300);}catch(InterruptedException e){
            e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t"+"共计卖出多少套："+ house.saleCount);}/**
     * 运行结果:
     * 1
     * 4
     * 3
     * 5
     * 2
     * main    共计卖出多少套：15
     *
     * 进程已结束,退出代码0
     */}

需求变化了

  • 希望各凭销售本事提成，按照出单数各自统计

  • 对应了前面的【每个线程都有自己专属的本地变量副本】

上述需求该如何处理呢

  • 利用ThreadLocal 线程隔离
  • 先初始化，给个0值（查看底层源码发现返回null值，如果不初始化，可能导致空指针异常）

阿里巴巴手册：必须回收自定义的ThreadLocal变量，尤其在线程池场景下，线程经常会被复用，如果不清理自定义的ThreadLocal变量，可能会影像后序业务逻辑和造成内存泄露等问题。尽量在代理中使用

try-finally

块进行回收。

调用remove()方法，不然很容易导致内存泄漏

Demo1

classHouse{int saleCount =0;publicsynchronizedvoidsaleHouse(){++ saleCount;}//两个都是创建一个线程局部变量并返回初始值/**
     * 一个比较老式的写法（这个阿里巴巴手册里也也有），initialValue()这个api已经淘汰了
     *//*ThreadLocal<Integer> saleVolume =  new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue(){
            return 0;
        }
    };*///java8之后带来的新写法ThreadLocal<Integer> saleVolume =ThreadLocal.withInitial(()->0);//withInitial当前常被用来初始化//人手一份，不用加锁也可以实现上述需求publicvoidsaleVolumeByThreadLocal(){
        saleVolume.set(1+saleVolume.get());}}publicclassThreadLocalDemo{publicstaticvoidmain(String[] args){House house =newHouse();for(int i =1;i <=5;i ++){newThread(()->{int size =newRandom().nextInt(5)+1;for(int j =1;j <= size;j ++){
                    house.saleHouse();
                    house.saleVolumeByThreadLocal();}System.out.println(Thread.currentThread().getName()+"\t"+"号销售卖出："+house.saleVolume.get());},String.valueOf(i)).start();}try{TimeUnit.MILLISECONDS.sleep(300);}catch(InterruptedException e){
            e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"\t"+"共计卖出多少套："+ house.saleCount);}/**
     * 运行结果:
     * 5   号销售卖出：5
     * 2   号销售卖出：1
     * 1   号销售卖出：5
     * 4   号销售卖出：5
     * 3   号销售卖出：2
     * main    共计卖出多少套：18
     *
     * 进程已结束,退出代码0
     */}

Demo2

//Demo2-主要演示线程池情况下，线程池中的线程会复用(不会自动清空)，而上面的都是新建一个ThreadclassMyData{ThreadLocal<Integer> threadLocalField =ThreadLocal.withInitial(()->0);publicvoidadd(){
        threadLocalField.set(1+ threadLocalField.get());}}/**
 * 根据阿里规范，需要对自定义的ThreadLocal进行回收，否则容易造成内存泄漏和业务逻辑问题(因为线程池中的线程会复用)
 */publicclassThreadLocalDemo{publicstaticvoidmain(String[] args){MyData myData =newMyData();ExecutorService threadPool =Executors.newFixedThreadPool(3);try{for(int i =0;i <10;i ++){
                threadPool.submit(()->{try{Integer beforeInt = myData.threadLocalField.get();
                        myData.add();Integer afterInt = myData.threadLocalField.get();System.out.println(Thread.currentThread().getName()+"\t"+"beforeInt"+beforeInt+"\t afterInt"+afterInt);}finally{
                        myData.threadLocalField.remove();}});}}catch(Exception e){
            e.printStackTrace();}finally{
            threadPool.shutdown();}}}/**
 * 运行情况:
 * 没有remove---出现了累积
 * pool-1-thread-1  beforeInt0   afterInt1
 * pool-1-thread-3  beforeInt0   afterInt1
 * pool-1-thread-2  beforeInt0   afterInt1
 * pool-1-thread-2  beforeInt1   afterInt2
 * pool-1-thread-2  beforeInt2   afterInt3
 * pool-1-thread-2  beforeInt3   afterInt4
 * pool-1-thread-2  beforeInt4   afterInt5
 * pool-1-thread-2  beforeInt5   afterInt6
 * pool-1-thread-3  beforeInt1   afterInt2
 * pool-1-thread-1  beforeInt1   afterInt2
 * 有remove-不会出现累积的情况
 * pool-1-thread-1  beforeInt0   afterInt1
 * pool-1-thread-3  beforeInt0   afterInt1
 * pool-1-thread-2  beforeInt0   afterInt1
 * pool-1-thread-1  beforeInt0   afterInt1
 * pool-1-thread-3  beforeInt0   afterInt1
 * pool-1-thread-1  beforeInt0   afterInt1
 * pool-1-thread-2  beforeInt0   afterInt1
 * pool-1-thread-1  beforeInt0   afterInt1
 * pool-1-thread-3  beforeInt0   afterInt1
 * pool-1-thread-2  beforeInt0   afterInt1
 */

ThreadLocal 的主要价值在于

线程隔离

，ThreadLocal 中的数据只属于当前线程，其本地值对别的线程是不可见的，在多线程环境下，可以防止自己的变量被其他线程篡改。由于线程间的数据相互隔离，避免了同步加锁带来的性能损失，提升了并发性的性能。

使用案例：

  • 数据库连接独享
  • Session数据管理

线程如何才能不争抢

  • 加入synchronized或者Lock控制资源的访问顺序
  • 利用ThreadLocal人手一份，大家各自安好，没必要抢夺

ThreadLocal比使用同步机制解决线程安全更简单，更方便，拥有更高的并发性

ThreadLocal源码分析

Thread，ThreadLocal，ThreadLocalMap关系

  • 根据官方API，Thread是程序中执行的线程；ThreadLocal类提供线程局部变量。

  • 先打开Thread.java类，发现每个Thread类里面有一个ThreadLocal类

  • ThreadLocal类里有静态类ThreadLocalMap

三者之间的关系、

在这里插入图片描述

threadLocalMap

实际上就是一个以

threadLocal

实例为key，任意对象为value的

Entry对象

。
当我们为threadLocal变量赋值，实际上就是

以当前threadLocal实例为key

，

值为value

的

Entry

往这个threadLocalMap中存放

在这里插入图片描述

小总结

近似可以理解为:
ThreadLocalMap从字面上就可以看出这是一个保存ThreadLocal对象的map(其实是以ThreadLocal为Key)，不过是经过了

两层包装

的ThreadLocal对象

  • 第一层包装是使用 WeakReference<ThreadLocal<?>> 将ThreadLocal对象变成一个弱引用的对象。
  • 第二层包裝是定义了一个专门的类 Entry 来扩展 WeakReference<ThreadLocals?>>。

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

3、ThreadLocal内存泄漏问题

3.1、什么是内存泄露

不再被使用的对象或者变量

占用的

内存

不能被回收，就是内存泄露

3.2、强引用，软引用，弱引用分别是什么？

整体架构
Java技术允许

使用finalize()方法

在垃圾收集器将对象从内存中清除出去之前 做必要的清理工作。

官方API : finalize()的通常目的是在对象被不可撤销地丢弃之前执行清理操作。

(也就是说，某个对象被干掉前还会调用finalize()清理一下）

  • Reference是强引用
  • SoftReference是软引用
  • WeakReference是弱引用
  • PhantomReference是虚引用

在这里插入图片描述

强引用（默认）

  • 当内存不足，JVM开始垃圾回收，对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收。

  • 强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。在 Java 中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。

  • 对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为 null，一般认为就是可以被垃圾收集的了(当然具体回收时机还是要看垃圾收集策略)。classMyObject{@Overrideprotectedvoidfinalize()throwsThrowable{//finalize的通常目的是在对象被不可撤销的丢弃之前进行清理操作//这个方法仅供测试使用System.out.println("finalize()被调用-------invoke finalize");}}publicclass referenceDemo {publicstaticvoidmain(String[] args){MyObject myObject =newMyObject();System.out.println("gc before"+myObject); myObject =null;//new 一个对象是一个强引用，如果不把他指为null，垃圾回收回收不了他System.gc();//人工开启gc 一般不用System.out.println("gc after "+myObject);}/** * 运行结果: * gc beforecom.hh.demo.MyObject@7f31245a * gc after null * finalize()被调用-------invoke finalize 这就是在对象丢弃之前进行一个清理操作，这里确实清理了 * * 进程已结束,退出代码0 */}

软引用

  • 软引用是一种相对强引用弱化了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。
  • 对于只有软引用的对象来说，- 当系统内存充足时它 不会 被回收，- 当系统内存不足时它 会 被回收。
  • 软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！
classMyObject{@Overrideprotectedvoidfinalize()throwsThrowable{//finalize的通常目的是在对象被不可撤销的丢弃之前进行清理操作//这个方法仅供测试使用System.out.println("finalize()被调用-------invoke finalize");}}publicclass referenceDemo {publicstaticvoidmain(String[] args){SoftReference<MyObject> softReference =newSoftReference<>(newMyObject());System.gc();try{TimeUnit.SECONDS.sleep(1);}catch(InterruptedException e){
            e.printStackTrace();}System.out.println("-------gc after内存够用"+softReference.get());try{byte[] bytes =newbyte[20*1024*1024];}catch(Exception e){
            e.printStackTrace();}finally{System.out.println("---------gc after内存不够"+softReference.get());}}/**
     * 测试前先设置 虚拟机大小 -Xmx10m
     * 运行结果:
     * -------gc after内存够用com.hh.demo.MyObject@7f31245a
     * ---------gc after内存不够null
     * finalize()被调用-------invoke finalize
     * Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
     *     at com.hh.demo.referenceDemo.main(referenceDemo.java:27)
     *
     * 进程已结束,退出代码1
     */}

弱引用

  • 弱引用 需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短，
  • 对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。
classMyObject{@Overrideprotectedvoidfinalize()throwsThrowable{//finalize的通常目的是在对象被不可撤销的丢弃之前进行清理操作//这个方法仅供测试使用System.out.println("finalize()被调用-------invoke finalize");}}publicclass referenceDemo {publicstaticvoidmain(String[] args){WeakReference<MyObject> weakReference =newWeakReference<>(newMyObject());System.out.println("-----gc before 内存够用 "+ weakReference.get());System.gc();try{TimeUnit.SECONDS.sleep(1);}catch(InterruptedException e){e.printStackTrace();}//暂停几秒钟线程System.out.println("----gc after内存够用 "+weakReference.get());}/**
     * 运行结果:
     * -----gc before 内存够用 com.hh.demo.MyObject@7f31245a
     * finalize()被调用-------invoke finalize
     * ----gc after内存够用 null
     *
     * 进程已结束,退出代码0
     */}

适用场景:
假如有一个应用需要读取大量的本地图片:

  • 如果每次读取图片都从硬盘读取则会严重影响性能,
  • 如果一次性全部加载到内存中又可能造成内存溢出。

此时使用软引用可以解决这个问题。

设计思路是：用一个HashMap来保存图片的路径和相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。

Map<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();

虚引用

  • 虚引用必须和引用队列 (ReferenceQueue)联合使用虚引用需要java.lang.ret.PhantomReterence类来实现,顾名思义， 就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队列 (ReferenceQueue)联合使用。
  • PhantomReference的get方法总是返回null虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一和确保对象被 finalize以后，做某些事情的通知机制。PhantomReference的get方法总是返回null，因此无法访问对应的引用对象。
  • 处理监控通知使用 换句话说，设置虚引用关联对象的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理，用来实现比finalize机制更灵活的回收操作。

在这里插入图片描述

在这里插入图片描述

classMyObject{@Overrideprotectedvoidfinalize()throwsThrowable{//finalize的通常目的是在对象被不可撤销的丢弃之前进行清理操作System.out.println("finalize()被调用-------invoke finalize");}}publicclass referenceDemo {publicstaticvoidmain(String[] args){MyObject myObject =newMyObject();ReferenceQueue<MyObject> referenceQueue =newReferenceQueue<>();PhantomReference<MyObject> phantomReference =newPhantomReference<>(myObject, referenceQueue);// System.out.println(phantomReference.get());//这里就是个null--虚引用的get()就是nullList<byte[]> list =newArrayList<>();newThread(()->{while(true)//模拟一个无限循环{
                list.add(newbyte[2*1024*1024]);try{TimeUnit.MILLISECONDS.sleep(1000);}catch(InterruptedException e){ e.printStackTrace();}System.out.println(phantomReference.get());}},"t1").start();newThread(()->{while(true){Reference<?extendsMyObject> reference = referenceQueue.poll();if(reference !=null){System.out.println("有虚对象加入队列了");}}},"t2").start();}/**
     * 运行结果:
     * finalize()被调用-------invoke finalize
     * null
     * null
     * null
     * Exception in thread "t1" java.lang.OutOfMemoryError: Java heap space
     *     at com.hh.demo.referenceDemo.lambda$main$0(referenceDemo.java:28)
     *     at com.hh.demo.referenceDemo$$Lambda$1/1023892928.run(Unknown Source)
     *     at java.lang.Thread.run(Thread.java:750)
     * 有虚对象加入队列了
     */}

4、GCRoots和四大引用小总结

在这里插入图片描述

在这里插入图片描述

  • 每个Thread对象维护着一个ThreadLocalMap的引用
  • ThreadLocalMap是ThreadLocal的静态内部类，用Entry来进行存储- 调用ThreadLocal的set()方法时，实际上就是往ThreadLocalMap设置值，key是ThreadLocal对象，值Value是传递进来的对象- 调用ThreadLocal的get()方法时，实际上就是往ThreadLocalMap获取值，key是ThreadLocal对象
  • ThreadLocal本身并不存储值，它只是自己作为一个key来让线程从ThreadLocalMap获取value，正因为这个原理，所以ThreadLocal能够实现“数据隔离”，获取当前线程的局部变量值，不受其他线程影响

ThreadLocal为什么要用弱引用呢？

在这里插入图片描述

为什么源代码用弱引用?

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

弱引用就没有问题了吗？

通常我们不会去new一个线程，而是复用线程池里面的线程，这就会引发一些问题

当我们为threadLocal变量赋值，实际上就是当前的

Entry(threadLocal实例为key，值为value)

往这个threadLocalMap中存放。Entry中的key是

弱引用

，当threadLocal外部强引用被置为null(tl=null),那么系统 GC 的时候，根据可达性分析，这个threadLocal实例就没有任何一条链路能够引用到它，这个ThreadLocal势必会被回收，这样一来，ThreadLocalMap中就会

出现key为null的Entry

，就没有办法访问这些key为null的Entry的value，如果当前线程再迟迟不结束的话（这个tl就不会被干掉），这些key为null的Entry的value就会一直存在一条强引用链：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value永远无法回收，造成

内存泄漏

。

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

但在实际使用中我们有时候会用

线程池

去维护我们的线程，比如在Executors.newFixedThreadPool()时创建线程的时候，为了复用线程 是不会结束的，所以threadLocal内存泄漏就值得我们小心

以下方法都对key== null 也就是脏Entry进行了处理，防止内存泄漏

  • expungeStaleEntry（清除ThreadLocal中的脏Entry的意思）
  • set()
  • get()
  • remove()

通过

expungeStaleEntry

，

cleanSomeSlots

,

replaceStaleEntry

这三个方法清理掉key为null的脏entry

最佳实践

  1. 一定要进行初始化避免空指针问题ThreadLocal.withInitial(()- > 初始化值);
  2. 建议把ThreadLocal修饰为static
  3. 用完记得手动remove
标签： java jvm 开发语言
本文转载自: https://blog.csdn.net/qq_56265207/article/details/129785128
版权归原作者 King Gigi. 所有， 如有侵权，请联系我们删除。
登录后发布评论

“ThreadLocal原理 、什么是内存泄漏”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航