ThreadLocal原理和使用

芒余

已于 2022-10-19 23:15:10 修改

阅读量3.8k

点赞数 5

分类专栏： JUC学习文章标签： java 开发语言

于 2022-10-19 23:05:20 首次发布

本文链接：https://blog.csdn.net/qq_45996900/article/details/127415591

版权

JUC学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

2.Thread、ThreadLocal、ThreadLocalMap的关系

2）强引用、软引用、弱引用、虚引用分别是什么？

3.4 为什么要用弱引用？不用如何？

3.5 最佳实践

4.总结

1.ThreadLocal简介

1.1大厂面试题

ThreadLocal中ThreadLocalMap的数据结构和关系？
ThreadLocal的key是弱引用，这是为什么？
ThreadLocal内存泄露问题你知道吗？
ThreadLocal中最后为什么要加remove方法？

1.2是什么

ThreadLocal提供线程局部变量。这些变量与正常的变量不同，因为每一个线程在访问ThreadLocal实例的时候（通过其get或set方法）都有自己的、独立初始化的变量副本。

ThreadLocal实例通常是类中的私有静态字段，使用它的目的是希望将状态（例如，用户ID或事务ID）与线程关联起来。

1.3能干什么

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

比如锁案例，资源类是使用同一部手机，多个线程抢夺同一部手机使用，假如人手一份是不是天下太平？？

1.4api介绍

变量和类型	方法	描述
T	get()	返回当前线程的此线程局部变量副本中的值。
protected T	initialValue()	返回此线程局部变量的当前线程的”初始值”。
void	remove()	删除此线程局部变量的当前线程值。
void	set(T value)	将此线程局部变量的当前线程副本设置为指定值。
static <S> ThreadLocal<S>	withInitial(Supplier<? extend S> supplier)	创建一个线程局部变量。

ThreadLocal<Integer> saleVolume=ThreadLocal.withInitial(()->0);

1.5案例

import java.util.Random;
import java.util.concurrent.TimeUnit;

class House{
    int saleCount=0;
    public synchronized void saleHouse(){
        saleCount++;
    }

    ThreadLocal<Integer> saleVolume=ThreadLocal.withInitial(()->0);

    public void saleVolumeByThreadLocal(int n){
        saleVolume.set(n);
    }

}
/*
需求1： 5个销售卖房子，集团高层只关心销售总量的准确统计数

需求2： 5个销售卖完随机数房子，各自独立销售额度，自己业绩按提成走，分灶吃饭，各个销售自己动手，丰衣足食

threadLocal用完以后使用remove方法，避免造成内存泄露

【强制】必须回收自定义的ThreadLocal 变量， 尤其在线程池场景下， 线程经常会被复用， 如果不清理
自定义的 Threadlocal 变量， 可能会影响后续业务逻辑和造成内存泄露等间题。 尽量在代理中使用try-finally 块进行回收
 */
public class ThreadLocalDemo {
    public static void main(String[] args) throws InterruptedException {
        House house = new House();
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                int size=new Random().nextInt(5)+1;
                try {
                    house.saleVolumeByThreadLocal(size);
                    for (int j = 0; j < size; j++) {
                        house.saleHouse();
                    }
                    System.out.println(Thread.currentThread().getName()+"\t号销售卖出："+house.saleVolume.get());
                }finally {
                    house.saleVolume.remove();
                }
            },String.valueOf(i)).start();
        }

        TimeUnit.MILLISECONDS.sleep(100);
        System.out.println(Thread.currentThread().getName()+"\t共计卖出多少套："+house.saleCount);
    }
}

运行结果

1.6总结

因为每个Thread内有自己的实例副本且该副本只由当前线程自己使用，既然其它Thread不可访问，那就不存在多线程间共享的问题。

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

如何才能不争抢

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

2.Thread、ThreadLocal、ThreadLocalMap的关系

ThreadLocalMap是ThreadLocal里面的静态内部类，Thread引用ThreadLocalMap。

3.ThreadLocal内存泄漏问题

3.1 从阿里Java开发手册讲起

3.2 什么是内存泄露？

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

3.3 什么会这样？

1）回顾ThreadLocalMap

2）强引用、软引用、弱引用、虚引用分别是什么？

整体架构

强引用（默认支持模式）

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

强引用是我们最常见的普通对象引用，只要还有强引用指向一个对象，就能表明对象还“活着”，垃圾收集器不会碰这种对象。

在Java中最常见的就是强引用，把一个对象赋给一个引用变量，这个引用变量就是一个强引用。

当一个对象被强引用变量引用时，它处于可达状态，它是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到，JVM也不会回收。因此强引用是造成Java内存泄漏的主要原因之一。

对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为null，一般认为就是可以被垃圾收集的了（当然具体回收时机还是要看垃圾收集策略）。

软引用

软引用是一种相对强引用弱华了一些的引用，需要用java.lang.ref.SoftReference类来实现，可以让对象豁免一些垃圾收集。

对于只有软引用的对象来说，

当系统内存充足时它不会被回收；

当系统内存不足时它会被回收。

软引用通常用在对内存敏感的程序中，比如高速缓存就有用到软引用，内存够用的时候就保留，不够用就回收！

弱引用

弱引用需要用java.lang.ref.WeakReference类来实现，它比软引用的生存期更短，

对于只有弱引用的对象来说，只要垃圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。

虚引用

1 虚引用必须和引用队列(ReferenceQueue)联合使用

虚引用需要java.lang.ref.PhantomReference类来实现，顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能垃圾回收器回收，它不能单独使用也不能通过它访问对象，虚引用必须和引用队 (ReferenceQueue)联合使用。

2 PhantomReference的get方法总是返回null

虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被finalize以后，做某些事情的通知机制。

PhantomReference的get方法总是返回null,因此无法访问对应的引用对象。

3 处理监控通知使用

换句话说，设置虚引用关联对象的唯一目的，就是在这个对象被收集器回收的时候收到一个系统通知或者后续添加进一步的处理，用来实现比finalize机制更灵活的回收操作。

软引用和弱引用的适用场景

假如有一个应用需要读取大量的本地图片：

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

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

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

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

案例

import java.lang.ref.*;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;

class MyObject{
    //这个方法一般不用复写，只是案例做个说明
    @Override
    protected void finalize() throws Throwable {
        //finalize的通带目的是在对象被不可撤销地丢弃之前执行清理操作。
        System.out.println("----------invoke finalize method~!!!");
    }
}
public class ReferenceDemo {
    public static void main(String[] args) throws InterruptedException {

        //虚引用
        MyObject myObject = new MyObject();
        ReferenceQueue<MyObject> referenceQueue = new ReferenceQueue<>();
        PhantomReference<MyObject> phantomReference = new PhantomReference<MyObject>(myObject,referenceQueue);

        ArrayList<byte[]> list = new ArrayList<>();
        new Thread(()->{
            while (true){
                list.add(new byte[1*1024*1024]);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(phantomReference.get()+"\tlist add ok");
            }
        },"t1").start();

        new Thread(()->{
            while (true){
                Reference<? extends MyObject> reference = referenceQueue.poll();
                if (reference!=null){
                    System.out.println("----有虚对象回收加入队列");
                    break;
                }
            }
        },"t2").start();
    }

    //弱引用
    private static void weakReference() {
        WeakReference<MyObject> weakReference = new WeakReference<MyObject>(new MyObject());
        System.out.println("gc before-----"+weakReference.get());
        System.gc();
        System.out.println("gc after-----"+weakReference.get());
    }

    //软引用
    private static void softReference() throws InterruptedException {
        SoftReference<MyObject> softReference = new SoftReference<>(new MyObject());
        System.out.println("gc after-----内存够用:"+softReference.get());

        try {
            //虚拟机内存设为10m，-Xms10m -Xmx10m
            byte []bytes=new byte[20*1024*1024];//开辟了一个20m的对象
            System.gc();
            TimeUnit.SECONDS.sleep(3);
        }finally {
            System.out.println("gc after-----不内存够用:"+softReference.get());
        }
    }

    private static void strongReference() {
        //默认强引用
        MyObject myObject = new MyObject();
        System.out.println("gc before:"+myObject);
        myObject=null;
        System.gc();//人工开始GC，一般不用
        System.out.println("gc after:"+myObject);
    }
}

3.4 为什么要用弱引用？不用如何？

line1新建了个ThreadLocal对象， t1 是强引用指向这个对象；
line2调用set（）方法后新建个Entry，通过源码可知Entry对象里的k是弱引用指向这个对象。

为什么源代码用弱引用？

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

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

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

此后我们调用get、set或remove方法时，就会尝试删除key为null的entry，可以释放value对象所占用的内存。

1 当我们为ThreadLocal变量赋值，实际上就是当前的Entry(threadLocal实例为key,值为value)往这个threadLocalMap中存放。Entry中的key是弱引用，当threadLocaI外部强引用被置为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内存泄漏就得我们小心。

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为nul时才会去回收整个entry、value，因此弱引用不能100%保证内存不泄露。我们要在不使用某个ThreadLocal对象后，手动调用remove方法来删除它，尤其是在线程池中，不仅仅是内存泄露的问题，因为线程池中的线程是重复使用的，意味着这个线程的ThreadLocalMap对象也是重复使用的，如果我们不手动调用remove方法，那么后面的线程就有可能获取到上个线程遗留下来的value值，造成bug.

底层

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

3.5 最佳实践

1)ThreadLocal.withinitial((） -> 初始化值）；

2)建议把ThreadLocal修饰为static

【参考】ThreadLocal对象使用static修饰，ThreadLocal无法去解决共享对象的更新问题。
说明：这个变量是针对对一个线程内所有操作共享的，所以设置为静态变量，所有此类实例共享此静态变量，也就是说在类第一次被使用时装载，只分配一块存储空间，所有此类的对象（只要是这个线程内定义的）都可以操控这个变量。

3)用完记得手动remove

4.总结

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

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

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

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

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

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

芒余

关注

5
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal原理和使用

ThreadLocal中ThreadLocalMap的数据结构和关系？ThreadLocal的key是弱引用，这是为什么？ThreadLocal内存泄露问题你知道吗？ThreadLocal中最后为什么要加remove方法？变量和类型方法描述Tget()返回当前线程的此线程局部变量副本中的值。返回此线程局部变量的当前线程的”初始值”。voidremove()删除此线程局部变量的当前线程值。void将此线程局部变量的当前线程副本设置为指定值。创建一个线程局部变量。
复制链接

扫一扫