ThreadLocal详解

15.1ThreadLocal简介

ThreadLocal叫做线程局部变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。

ThreadLoal 线程局部变量，同一个ThreadLocal所包含的对象，在不同的 Thread 中有不同的副本。即：每个 Thread 有自己的实例副本，且其它 Thread 不可访问，那就不存在多线程间共享的问题。

总的来说，ThreadLocal 适用于每个线程需要自己独立的实例且该实例需要在多个方法中被使用，也即变量在线程间隔离而在方法或类间共享的场景。

15.2ThreadLocal和Synchronized的区别

ThreadLocal和Synchonized都用于解决多线程并发访问。

但是ThreadLocal与synchronized有本质的区别：

Synchronized用于线程间的数据共享，而ThreadLocal则用于线程间的数据隔离。

Synchronized是利用锁的机制，使变量或代码块在某一时该只能被一个线程访问。而ThreadLocal为每一个线程都提供了变量的副本，使得每个线程在某一时间访问到的并不是同一个对象，这样就隔离了多个线程对数据的数据共享，而Synchronized却正好相反，它用于在多个线程间通信时能够获得数据共享。

15.3ThreadLocal的API

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

案例：

class Saler {
    //   创建一个ThreadLocal对象，用于存放每个线程的数据
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void addNumberThreadLocal() {
        threadLocal.set(threadLocal.get() + 1);
    }
}

/**
 * 销售演示
 *
 * @author Xu huaiang
 * @date 2023/07/06
 */
public class SaleDemo {
    public static void main(String[] args) {
        Saler saler = new Saler();
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 1; i <= 5; i++) {
            new Thread(() -> {
                int number = new Random().nextInt(5) + 1;
//                每位销售卖出的商品数量
                for (int j = 1; j <= number; j++) {
                    saler.addNumberThreadLocal();
                }
                System.out.println(Thread.currentThread().getName() + "号销售" + "卖出了" + number + "件商品");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }    
    }
}

15.4ThrealLocal变量回收

阿里巴巴java开发手册中规定：必须回收自定义的Threadlocal 变量，尤其在线程池场景下，线程经常会被复用，如果不清理自定义的Threadlocal变量，可能会影响后续业务逻辑和造成内存泄露等问题。尽量在代理中使用try-finally块进行回收。

案例：

class ThrealLocalData {
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void addNumberThreadLocal() {
        threadLocal.set(threadLocal.get() + 1);
    }
}

public class VariableRecovery {

    public static void main(String[] args) {
//        创建一个ThreadLocal对象，用于存放每个线程的数据
        ThrealLocalData threalLocalData = new ThrealLocalData();
//        获取到线程池
        ThreadPoolExecutor threadPool = ThreadPoolService.getThreadPool();
        try {
            for (int i = 0; i < 20; i++) {
                threadPool.execute(() -> {
                    Integer before = threalLocalData.threadLocal.get();
                    System.out.println(Thread.currentThread().getName() + "号线程执行前的值：" + before);
                    threalLocalData.addNumberThreadLocal();
                    threalLocalData.threadLocal.get();
                    System.out.println(Thread.currentThread().getName() + "号线程执行后的值：" + threalLocalData.threadLocal.get());
                });
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            threadPool.shutdown();
        }
    }
}

查看结果：出现线程复用

使用remove()函数删除此线程局部变量在当前线程当中的值。即使线程复用也不会出现重复值。

class ThrealLocalData {
    ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void addNumberThreadLocal() {
        threadLocal.set(threadLocal.get() + 1);
    }
}

public class VariableRecovery {

    public static void main(String[] args) {
//        创建一个ThreadLocal对象，用于存放每个线程的数据
        ThrealLocalData threalLocalData = new ThrealLocalData();
//        获取到线程池
        ThreadPoolExecutor threadPool = ThreadPoolService.getThreadPool();
        try {
            for (int i = 0; i < 20; i++) {
                threadPool.execute(() -> {
                    try {
                        Integer before = threalLocalData.threadLocal.get();
                        System.out.println(Thread.currentThread().getName() + "号线程执行前的值：" + before);
                        threalLocalData.addNumberThreadLocal();
                        threalLocalData.threadLocal.get();
                        System.out.println(Thread.currentThread().getName() + "号线程执行后的值：" + threalLocalData.threadLocal.get());
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {
                        threalLocalData.threadLocal.remove();
                    }
                });
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            threadPool.shutdown();
        }
    }
}

15.5ThreadLocal源码分析

查看Thread类：

可以看到Thread 类中包含一个名为 threadLocals 的字段，它是一个 ThreadLocal.ThreadLocalMap 类型的对象。这个字段用于存储与当前线程相关联的 ThreadLocal 变量。每个 ThreadLocal 对象都会在 threadLocals 中维护一个与当前线程相关联的变量副本。这样，每个线程都可以通过 ThreadLocal 对象访问自己的变量副本，而不会影响其他线程的变量副本。

查看ThreadLcoal类当中，发现ThreadLocalMap为ThreadLocal类的静态内部类。

而ThreadLocalMap 中的键值对存储在一个名为 Entry 的内部类中。Entry 类继承自 WeakReference 类，因此它对键的引用是弱引用。这意味着，如果一个 ThreadLocal 对象不再被使用，那么它所对应的键值对就会在下一次垃圾回收时被回收。

Thread 是 Java 中表示线程的类。

ThreadLocal 是一个类，它提供了线程局部变量 。这些变量与它们的普通副本不同，因为每个访问它的线程（通过其 get 或 set 方法）都有自己独立初始化的变量副本。

ThreadLocalMap 是 ThreadLocal 的一个静态内部类，它是一个定制的哈希映射，仅用于维护线程局部值。ThreadLocalMap实际上就是一个以ThreadLocal实例为Key，任意对象为value的Entry对象（弱引用对象），当我们为ThreadLocal变量赋值，实际上就是以当前ThreadLocal实例为Key，值为value的Entry往这个ThreadLocalMap中存放。

每个 Thread 对象都有一个 ThreadLocalMap 属性，用于存储与该线程关联的线程局部变量。当您调用 ThreadLocal 的 set 或 get 方法时，实际上是在操作当前线程的 ThreadLocalMap。所以ThreadLocalMap 是一个中间媒介，它将 ThreadLocal 变量与特定的 Thread 关联起来。

即ThreadLocal本身并不存储值，它只是作为一个key来让线程从ThreadLocalMap中获取value。真正的存储结构是ThreadLocal中的内部类ThreadLocalMap，每个Thread对象维护着一个ThreadLocalMap的引用，用Entry来进行存储。

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

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

15.6ThreadLocal的内存泄露问题

15.6.1什么是内存泄露

内存泄漏：就是将对一个不再被引用的对象进行GC的时候，发现其还存在对象的引用，从而导致的该对象不能回收仍然占用内存的问题，这就是内存泄漏。

15.6.2引用的分类

我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存中；如果内存空间在进行垃圾收集后还是很紧张，则可以抛弃这些对象。

【既偏门又非常高频的面试题】强引用、软引用、弱引用、虚引用有什么区别？具体使用场景是什么？

在JDK1.2版之后，Java对引用的概念进行了扩充，将引用分为：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）这4种引用强度依次逐渐减弱。

除强引用外，其他3种引用均可以在java.lang.ref包中找到它们的身影。如下图，显示了这3种引用类型对应的类，开发人员可以在应用程序中直接使用它们。

Reference子类中只有终结器引用是包内可见的，其他3种引用类型均为public，可以在应用程序中直接使用

强引用（StrongReference）：最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj = new Object()”这种引用关系。只有当它不再被引用时，垃圾回收器才会回收它所指向的对象。

软引用（SoftReference）：垃圾回收器会在内存不足时回收它所指向的对象，即使这个对象仍然被引用。

弱引用（WeakReference）：当进行垃圾回收时，无论内存空间是否足够，都会回收掉被弱引用关联的对象。

虚引用（PhantomReference）：它不会影响垃圾回收器对它所指向的对象的回收。虚引用主要用于跟踪对象被垃圾回收器回收的时间。

15.6.3强引用（Strong Reference）—不回收

在Java程序中，最常见的引用类型是强引用（普通系统99%以上都是强引用），也就是我们最常见的普通对象引用，也是默认的引用类型。

当在Java语言中使用new操作符创建一个新的对象，并将其赋值给一个变量的时候，这个变量就成为指向该对象的一个强引用。

强引用所指向的对象在任何时候都不会被系统回收，当然是对于还被引用的对象。对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将相应（强）引用赋值为nu11，就是可以当做垃圾被收集了，当然具体回收时机还是要看垃圾收集策略。

相对的，软引用、弱引用和虚引用的对象是软可触及、弱可触及和虚可触及的，在一定条件下，都是可以被回收的。所以，强引用是造成Java内存泄漏的主要原因之一。

强引用例子

StringBuffer str = new StringBuffer("hello mogublog");

局部变量str指向StringBuffer实例所在堆空间，通过str可以操作该实例，那么str就是StringBuffer实例的强引用

对应内存结构

此时，如果再运行一个赋值语句

StringBuffer str1 = str;

对应的内存结构

本例中的两个引用，都是强引用，强引用具备以下特点：

强引用可以直接访问目标对象。

强引用所指向的对象在任何时候都不会被系统回收，虚拟机宁愿抛出OOM异常，也不会回收强引用所指向对象（在还在被引用的前提下）。

强引用可能导致内存泄漏。

15.6.4软引用（Soft Reference）—内存不足即回收

软引用是用来描述一些还有用，但非必需的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。

软引用通常用来实现内存敏感的缓存。比如：高速缓存就有用到软引用。如果还有空闲内存，就可以暂时保留缓存，当内存不足时清理掉，这样就保证了使用缓存的同时，不会耗尽内存。

垃圾回收器在某个时刻决定回收软可达的对象的时候，会清理软引用，并可选地把引用存放到一个引用队列（Reference Queue）。

类似弱引用，只不过Java虚拟机会尽量让软引用的存活时间长一些，迫不得已才清理。

在JDK1.2版之后提供了java.lang.ref.SoftReference类来实现软引用

Object obj = new Object(); // 声明强引用
SoftReference<Object> sf = new SoftReference<>(obj);
obj = null; //销毁强引用

15.6.5弱引用（Weak Reference）—GC即回收

弱引用也是用来描述那些非必需对象，只被弱引用关联的对象只能生存到下一次垃圾收集发生为止。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。

但是，由于垃圾回收器的线程通常优先级很低，因此，并不一定能很快地发现持有弱引用的对象。在这种情况下，弱引用对象可以存在较长的时间。

弱引用和软引用一样，在构造弱引用时，也可以指定一个引用队列，当弱引用对象被回收时，就会加入指定的引用队列，通过这个队列可以跟踪对象的回收情况。

软引用、弱引用都非常适合来保存那些可有可无的缓存数据。如果这么做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。而当内存资源充足时，这些缓存数据又可以存在相当长的时间，从而提升系统性能。

在JDK1.2版之后提供了WeakReference类来实现弱引用

Object obj = new Object(); // 声明强引用
WeakReference<Object> sf = new WeakReference<>(obj);
obj = null; //销毁强引用

弱引用对象与软引用对象的最大不同就在于，当GC在进行回收时，需要通过算法检查是否回收软引用对象，而对于弱引用对象，GC总是进行回收。弱引用对象更容易、更快被GC回收。

面试题：你开发中使用过WeakHashMap吗？

WeakHashMap用来存储图片信息，可以在内存不足的时候，及时回收，避免了OOM

15.6.6虚引用（Phantom Reference）—对象回收跟踪

也称为“幽灵引用”或者“幻影引用”，是所有引用类型中最弱的一个。

一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。

它不能单独使用，也无法通过虚引用来获取被引用的对象。当试图通过虚引用的get()方法取得对象时，总是null。

为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。比如：能在这个对象被收集器回收时收到一个系统通知。

虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象后，将这个虚引用加入引用队列，以通知应用程序对象的回收情况。

由于虚引用可以跟踪对象的回收时间，因此，也可以将一些资源释放操作放置在虚引用中执行和记录。

在JDK1.2版之后提供了PhantomReference类来实现虚引用。

Object obj = new Object(); // 声明强引用
ReferenceQueue phantomQueue = new ReferenceQueue();
PhantomReference<Object> sf = new PhantomReference<>(obj, phantomQueue);
obj = null;

15.6.7ThreadLocal内存泄漏

ThreadLocalMap是ThreadLocal的内部类，它用于存储每个线程的变量副本。ThreadLocalMap的键是ThreadLocal实例，而值是线程的变量副本。由于ThreadLocalMap的生命周期与Thread一样长，如果没有手动删除对应的键，那么就会导致内存泄漏。而在ThreadLocalMap中，键是弱引用，而值是强引用。那么在进行垃圾回收时，键必然会被回收，但值不会被回收。这样就会导致内存泄漏。

为了避免这种情况，可以在不再使用 ThreadLocal 对象时调用它的 remove() 方法来清除对应的值。这样可以确保不会发生内存泄漏。(也就是在15.4章节说明的ThreadLocal变量回收)。

15.6.8ThreadLocalMap为什么使用弱引用

ThreadLocalMap 使用弱引用来引用键（ThreadLocal 对象），这样可以避免内存泄漏。

在 ThreadLocalMap 中，每个 ThreadLocal 对象都对应一个键值对，其中键是 ThreadLocal 对象，值是与当前线程相关联的变量副本。如果 ThreadLocalMap 使用强引用来引用键，那么即使 ThreadLocal 对象不再被使用而被其他对象引用，它所对应的键仍然会存在于 ThreadLocalMap 中。那么它所对应的值也不会被垃圾回收器回收，从而导致内存泄漏。

为了避免这种情况，ThreadLocalMap 使用弱引用来引用键。这样，在垃圾回收时，无论 ThreadLocal 对象是否仍然被使用，它所对应的键都会被回收。这样可以确保不会发生内存泄漏。而ThreadLocalMap中对应的Entry的key会变为null 。

15.6.9ThreadLocalMap使用弱引用存在的问题

当ThreadLocalMap中对应的Entry的key变为null时，仍然存在内存泄漏的问题。这是因为Entry中的value仍然被引用，而且不会被垃圾回收器回收。为了避免这个问题，ThreadLocalMap的实现会定期检查并清理key为null的Entry。此外，在使用ThreadLocal时，也应该注意在不再使用时及时调用remove方法来删除对应的value。

JUC

#Java #JUC #多线程

ThreadLocal详解

https://xhablog.online/2023/07/06/ThreadLocal详解/

作者

Xu huaiang

发布于

2023年7月6日

许可协议

JUC 上一篇

JVM内存模型概述下一篇