7.9 ThreadLocal

于 2024-07-13 17:39:21 发布
阅读量553 收藏 8
点赞数 22
分类专栏： JUC 文章标签： java juc 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dingd1234/article/details/140403493
版权

简介

是什么

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

能干嘛

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

API 介绍

image.png
image.png
image.png

代码示例

问题描述：5个销售买房子，集团只关心销售总量的准确统计数，按照总销售额统计，方便集团公司给部分发送奖金，即 5 个线程同时操作一个共享变量销售总量，为了保证数据安全，只能加锁

class House {
    int saleCount = 0;

    public synchronized void saleHouse() {
        saleCount++;
    }
}

public class ThreadLocalDemo {
    public static void main(String[] args) {
        House house = new House();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                int size = new Random().nextInt(5) + 1;
                System.out.println(Thread.currentThread().getName() + "：" + size);
                for (int j = 0; j <= size; j++) {
                    house.saleHouse();
                }
            }, "线程" + i).start();
        }
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "共计卖出多少套" + house.saleCount);
    }
}

输出结果
image.png
需求变更：希望各自分灶吃饭，各凭销售本事提成，按照出单数各自统计。比如某房产中介销售都有自己的销售额指标，自己专属自己的，不和别人掺和。

class House {
    int saleCount = 0;

    public synchronized void saleHouse() {
        saleCount++;
    }

    ThreadLocal<Integer> saleVolume = ThreadLocal.withInitial(() -> 0);
    public void saleVolumeByThreadLocal() {
        saleVolume.set(1 + saleVolume.get());
    }
}


public class ThreadLocalDemo {
    public static void main(String[] args) {
        House house = new House();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                int size = new Random().nextInt(5) + 1;
                try {
                    for (int j = 0; j <= size; j++) {
                        house.saleHouse();
                        house.saleVolumeByThreadLocal();
                    }
                } finally {
                    house.saleVolume.remove();
                }
                System.out.println(Thread.currentThread().getName() + "号销售卖出：" + house.saleVolume.get());
            }, String.valueOf(i)).start();
        }
        try {
            TimeUnit.MILLISECONDS.sleep(300);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "共计卖出多少套" + house.saleCount);
    }
}

注意：必须回收自定义的 ThreadLocal 变量，尤其在线程池场景下，线程经常会被复用，如果不清理自定义的 ThreadLocal 变量，可能会影响到后续业务逻辑和造成内存泄漏等问题。尽量在代理中使用**try-finally**块进行回收。

// 正例
objectThreadLocal.set(userInfo);
try {
    // ...
} finally {
    objectThreadLocal.remove();
}

线程复用：

public class ThreadLocalDemo2 {
    public static void main(String[] args) {
        MyData myData = new MyData();
        ExecutorService pool = Executors.newFixedThreadPool(3);
        try {
            for (int i = 0; i < 10; i++) {
                pool.submit(() -> {
                    Integer beforeInt = myData.threadLocalField.get();
                    myData.add();
                    Integer afterInt = myData.threadLocalField.get();
                    System.out.println(Thread.currentThread().getName() + "\t" +
                            "beforeInt: " + beforeInt + "\t" +
                            "afterInt: " + afterInt);
                });
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            pool.shutdown();
        }
    }
}

class MyData {
    ThreadLocal<Integer> threadLocalField = ThreadLocal.withInitial(() -> 0);

    public void add() {
        threadLocalField.set(1 + threadLocalField.get());
    }
}

输出结果
image.png
每次循环 ThreadLocal 中存储的值都是在上一个线程执行的基础之上加 1，如果线程足够大，这样重复利用资源，肯定会导致内存泄漏。现在要求是每次循环都从 0 开始，对代码做如下修改：

public class ThreadLocalDemo2 {
    public static void main(String[] args) {
        MyData myData = new MyData();
        ExecutorService pool = Executors.newFixedThreadPool(3);
        try {
            for (int i = 0; i < 10; i++) {
                pool.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 {
                        // 增加 remove 方法，用一次清除一次
                        myData.threadLocalField.remove();
                    }
                });
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            pool.shutdown();
        }
    }
}

输出结果
image.png

总结

  • 因为每个 Thread 内有自己的实例副本且该副本只由当前线程自己使用，既然其他 Thread 不可访问，那就不存在多线程间贡献的问题。
  • 统一设置初始值，但是每个线程对这个值的修改都是各自线程互相独立的
  • 如何才能不争抢
    • 加入 synchronized 或者 Lock 控制资源的访问顺序
    • 人手一份，大家各自安好，没必要抢夺

ThreadLocal 源码分析

Thread、ThreadLocal、ThreadLocalMap 是什么关系？

public class Thread implements Runnable {
    // 会在 ThreadLocal 类中对该变量进行赋值操作
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

每个线程都会有一个 ThreadLocal.ThreadLocalMap 实例变量。各自线程，人手一份。

public class ThreadLocal<T> {
    static class ThreadLocalMap {
        // Entry 为 ThreadLocalMap 的静态内部类
        static class Entry extends WeakReference<ThreadLocal<?>> {
            Object value;
            // Entry 中的 key 为 ThreadLocal
            // Entry 的构造函数
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        // ...
    }
}

ThreadLocalMap 是 ThreadLocal 的静态内部类。
image.png
ThreadLocalMap 实际上就是一个以 ThreadLocal 实例为 key，任意对象为 value 的 Entry 对象。
当我们为 ThreadLocal 变量赋值，实际上就是以当前 ThreadLocal 实例为 key，值为 value 的 Entry 往这个 ThreadLocalMap 中存放

public class ThreadLocal<T> {
    void createMap(Thread t, T firstValue) {
        // 将当前实例对象作为 ThreadLocalMap 的 key
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    public T get() {
        Thread t = Thread.currentThread();
        // 根据当前线程获取对应的 threadLocals 
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            // 根据当前线程从 Entry 中获取对应的 value
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 如果 map 为空，设置初始值
        return setInitialValue();
    }

    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);
        return value;
    }

    // 初始化值为 null，所以在写代码时，一定要设置初始值，重写该方法，
    // 否则容易报空指针异常
    protected T initialValue() {
        return null;
    }

    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }
}

image.png
ThreadLocal 是一个壳子，真正的存储结构是 ThreadLocal 里的 ThreadLocalMap 这个内部类，每个 Thread 对象维护者一个 ThreadLocalMap 的引用，ThreadLocalMap 是 ThreadLocal 的内部类，用 Entry 来进行存储。

  • 调用 ThreadLocal 的 set() 方法时，实际上就是往 ThreadLocalMap 设置值，key 是 ThreadLocal 对象，值 value 是传递进来的对象
  • 调用 ThreadLocal 的 get() 方法时，实际上就是从 ThreadLocalMap 获取值，key 是 ThreadLocal 对象

ThreadLocal 本身并不存储值（ThreadLocal 是一个壳子）。它只是自己作为一个 key 来让线程从 ThreadLocalMap 中获取 value。正因为这个原理，所以 ThreadLocal 能够实现”数据隔离“，获取当前线程的局部变量值，不受其他线程影响。
近似的可以理解为：
ThreadLocalMap 从字面上就可以看出这是一个保存 ThreadLocal 对象的 map（其实是以 ThreadLocal 为 key），不过是经过了两层包装的 ThreadLocal 对象：
image.png
JVM 内部维护了一个线程版的 Map<ThreadLocal, Value>（通过 ThreadLocal 对象的 set 方法，结果把 ThreadLocal 对象自己当作 key，放进了 ThreadLocalMap 中），每个线程要用到这个 T 的时候，用当前的线程去 Map 里面获取，通过这样让每个线程都拥有了自己独立的变量，人手一份，竞争条件被彻底清除，在并发模式下是绝对安全的变量。

ThreadLocal 内存泄露问题

什么是内存泄漏

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

谁惹的祸

ThreadLocalMap 与 WeakReference

image.png
ThreadLocalMap 从字面上就可以看出这是一个保存 ThreadLocal 对象的 Map（以 ThreadLocal 为 key），不过是经过了两层包装的 ThreadLocal 对象：

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

引用

image.png
关于强软弱虚引用的介绍可以看 JVM 第十六章：垃圾回收算法 第 6 小节： 再谈引用

  • 强引用：
    • 对于强引用的对象，就算是出现了OOM也不会对该对象进行回收，死都不收，当一个对象被强引用变量引用时，它处于可达状态，是不可能被垃圾回收机制回收的，即使该对象以后永远都不会被用到，JVM也不会回收，因此强引用是造成Java内存泄露的主要原因之一。
  • 软引用：
    • 是一种相对强引用弱化了一些的引用，对于只有软引用的对象而言，当系统内存充足时，不会被回收，当系统内存不足时，他会被回收，软引用通常用在对内存敏感的程序中，比如高速缓存，内存够用就保留，不够用就回收。
  • 弱引用：
    • 比软引用的生命周期更短，对于只有弱引用的对象而言，只要垃圾回收机制一运行，不管JVM的内存空间是否足够，都会回收该对象占用的内存。
  • 软引用和弱引用的使用场景----->假如有一个应用需要读取大量的本地图片：
    • 如果每次读取图片都从硬盘读取则会严重影响性能
    • 如果一次性全部加载到内存中又可能会造成内存溢出
    • 此时使用软应用来解决，设计思路时：用一个HashMap来保存图片的路径和与相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，有效避免了OOM的问题
  • 虚引用：
    • 虚引用必须和引用队列联合使用，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都有可能被垃圾回收器回收，它不能单独使用也不能通过它访问对象。
    • 虚引用的主要作用是跟踪对象被垃圾回收的状态。仅仅是提供了一种确保对象被finalize后，做某些事情的通知机制。换句话说就是在对象被GC的时候会收到一个系统通知或者后续添加进一步的处理，用来实现比finalize机制更灵活的回收操作。

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

public void function01() {
    ThreadLocal<String> tl = new ThreadLocal<>();    // line1
    tl.set("zzyybs@126.com");                        // line2
    tl.get();                                        // line3
}
  • line1 新建了一个 ThreadLocal 对象，t1 是强引用指向这个对象
  • line2 调用 set() 方法后新建一个 Entry，通过源码可知 Entry 对象里的 key 是弱引用指向这个对象。

image.png
为什么源代码用弱引用？
当 function01 方法执行完毕后，栈帧销毁强引用，tl 也就没有了。但此时线程的 ThreadLocalMap 里某个 Entry 的 key 引用还指向这个对象。

  • 若这个 key 引用是强引用，就会导致 key 指向的 ThreadLocal 对象及 value 指向的对象不能被 gc 回收，造成内存泄漏
  • 若这个 key 引用是弱引用，就大概率会减少内存泄漏的问题（还有一个 key 为 null 的雷）。使用弱引用，就可以使 ThreadLocal 对象在方法执行完毕后顺利被回收，且 Entry 的 key 引用指向为 null。

使用弱引用就万事大吉了吗？

image.png
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对象后，手动调用remove方法来删除它，尤其是在线程池中，不仅仅是内存泄漏的问题，因为线程池中的线程是重复使用的，意味着这个线程的ThreadLocalMap对象也是重复使用的，如果我们不手动调用remove方法，那么后面的线程就有可能获取到上个线程遗留下来的value值，造成bug。
清除脏Entry----key为null的entry

  • set()方法

image.png

  • get() 方法

image.png

  • remove() 方法：寻找脏 Entry，即 key = null 的 Entry，然后进行删除

image.png
从前面的 set，getEntry，remove 方法看出，在 ThreadLocal 的生命周期里，针对 ThreadLocal 存在的内存泄漏问题，都会通过expungeStateEntry、cleanSomeSlots、replaceStateEntry这三个方法清理掉 key 为 null 的脏 Entry。

最佳实践

  • ThreadLocal.withInitial(() -> 初始化值)一定要初始化
  • 建议把 ThreadLocal 修饰为 static
  • 用完记得手动 remove

总结

  • ThreadLocal 并不解决线程间共享数据的问题
  • ThreadLocal 适用于变量在线程间隔离且在方法间共享的场景
  • ThreadLocal 通过隐式的在不同线程内创建独立实例副本避免了实例线程安全的问题
  • 每个线程持有一个只属于自己的专属 Map 并维护了 ThreadLocal 对象与具体实例的映射，该 Map 由于只被持有它的线程访问，故不存在线程安全以及锁的问题。
  • ThreadLocalMap 的 Entry 对 ThreadLocal 的引用为弱引用，避免了 ThreadLocal 对象无法被回收的问题
  • 都会通过expungeStateEntry、cleanSomeSlots、replaceStateEntry这三个方法回收键为 null 的脏 Entry 对象的值（即具体实例）以及 Entry 对象本身，从而防止内存泄漏，属于安全加固的方法。
喵先森爱吃鱼
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值