深入理解ThreadLocal原理

本文详细解释了Java中的ThreadLocal如何实现线程间资源隔离和线程内资源共享,涉及ThreadLocalMap的工作原理、扩容机制、哈希冲突处理以及为何使用弱引用。还讨论了ThreadLocal中value的内存回收策略,强调了remove方法在防止内存泄漏的重要性。
摘要由CSDN通过智能技术生成


1- 什么是ThreadLocal ?

  • ThreadLocal是Java中的一个工具类,它提供了线程局部变量,即这些变量对于使用它的每个线程来说都是独立的。每个线程都可以通过ThreadLocal存储、访问和更新自己的变量副本,而不会与其他线程的变量副本冲突。

2- ThreadLocal的作用?

ThreadLocal 两大作用

  • ① 线程间资源隔离
  • ② 线程内资源共享

ThreadLocal实现线程间资源隔离

public class ThreadLocalExample {

    // 创建一个 ThreadLocal 实例,用于存储每个线程的计数器
    private static final ThreadLocal<Integer> threadLocalCounter = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        // 创建三个线程,每个线程都会更新自己的计数器
        for (int i = 0; i < 3; i++) {
            Thread thread = new Thread(() -> {
                // 获取当前线程的计数器
                int counter = threadLocalCounter.get();
                // 更新计数器的值
                counter += 5;
                // 将更新后的值重新设置到 ThreadLocal 中
                threadLocalCounter.set(counter);
                // 打印当前线程的计数器值
                System.out.println(Thread.currentThread().getName() + " counter: " + threadLocalCounter.get());
            }, "Thread-" + i);
            thread.start();
        }
    }
}

输出:
image.png
分析

  • threadLocalCounter是一个ThreadLocal实例,它通过withInitial方法初始化,为每个线程提供了一个初始值0。
  • 在输出结果中,我们可以看到每个线程都打印出了counter: 5 ,这表明每个线程都成功地将自己的计数器从0增加到了5,而且这个增加操作没有影响到其他线程的计数器。这正是ThreadLocal实现线程间资源隔离的效果。

ThreadLocal实现线程内资源共享

public class ThreadLocalExample2 {
    // 创建一个 ThreadLocal 实例,用于存储每个线程的会话信息
    private static final ThreadLocal<String> threadLocalSession = new ThreadLocal<>();

    public static void main(String[] args) {
        // 创建两个线程,模拟两个用户的会话
        for (int i = 1; i <= 2; i++) {
            final int userId = i;
            Thread thread = new Thread(() -> {
                // 在 ThreadLocal 中设置当前线程的会话信息
                String session = "UserSessionForUser" + userId;
                threadLocalSession.set(session);

                // 执行线程内的不同方法,它们都可以访问到同一个会话信息
                performAction("add item to cart");
                performAction("checkout");
                performAction("logout");

                // 清理资源,避免内存泄漏
                threadLocalSession.remove();
            }, "Thread-for-User-" + userId);
            thread.start();
        }
    }

    // 模拟一个操作,该操作需要访问会话信息
    private static void performAction(String action) {
        // 从 ThreadLocal 获取当前线程的会话信息
        String session = threadLocalSession.get();
        System.out.println(Thread.currentThread().getName() + " performing action: " + action + " with " + session);
    }

}

输出:
image.png
分析

  • 在输出结果中,我们可以看到每个线程(例如Thread-for-User-1和Thread-for-User-2)都能够连续执行add item to cart、checkout 和 logout操作,并且每个操作都使用了与该线程关联的会话信息(UserSessionForUser1和UserSessionForUser2)。这表明ThreadLocal确实实现了同一线程内的资源共享。

3- ThreadLocal 原理

3-1 ThreadLocalMap

  • **实际上 ThreadLocal 实现了资源的关联,本质上是通过 **ThreadLocalMap实现的线程间资源隔离

其原理是,每个线程内有一个ThreadLocalMap类型的成员变量,用来存储资源对象

  • ① 调用set方法,就是以ThreadLocal自己作为key,资源对象作为value,放入当前线程的 ThreadLocalMap集合中
  • ② 调用get方法,就是以ThreadLocal自己作为key,到当前线程中查找关联的资源值
  • ③ 调用remove方法,就是以ThreadLocal自己作为 key,移除当前线程关联的资源值

3-2 ThreadLocalMap的扩容

🔑1. 为什么会发生扩容?
  • 一个线程可以拥有多个 ThreadLocal 对象,每个 ThreadLocal 对象都可以存储在同一个线程的 ThreadLocalMap 中,而且彼此独立。
  • 这就是为什么 ThreadLocalMap 的容量是16(默认初始容量)并且具有扩容机制的原因。扩容机制确保了当一个线程使用多个 ThreadLocal 对象时,ThreadLocalMap 能够适应更多的条目。

例子

public class ThreadLocalExample {

    // 创建两个不同的 ThreadLocal 实例
    private static final ThreadLocal<String> threadLocal1 = new ThreadLocal<>();
    private static final ThreadLocal<String> threadLocal2 = new ThreadLocal<>();

    public static void main(String[] args) {
        // 在同一个线程中为不同的 ThreadLocal 实例设置值
        threadLocal1.set("Value for ThreadLocal 1");
        threadLocal2.set("Value for ThreadLocal 2");

        // 每个 ThreadLocal 实例的值是独立的
        System.out.println("ThreadLocal 1 contains: " + threadLocal1.get());
        System.out.println("ThreadLocal 2 contains: " + threadLocal2.get());
    }
}
  • 在这个例子中,我们有两个 ThreadLocal 实例。即使它们都在同一个线程中使用,每个 ThreadLocal 实例也会在 ThreadLocalMap 中占据不同的槽位。因此,threadLocal1.set()threadLocal2.set() 操作不会相互覆盖,因为它们是两个独立的条目。
  • 如果一个线程使用的 ThreadLocal 实例数量超过了 ThreadLocalMap 的当前容量,ThreadLocalMap 就会根据需要进行扩容,以便为新的 ThreadLocal实例提供空间。
🔑2. ThreadLocalMap索引计算?
  • 索引计算:当线程每创建一个新的 ThreadLocal 对象时候,会为当前 ThreadLocal对象分配一个 哈希值,最初哈希值为 0 因此,如下图 ThreadLocal1 插入的位置为 0
  • 此时如果又创建 ThreadLocal2 会在 0 的基础上加一个 数字,会根据这个数字计算出当前ThreadLocal2 的索引,比如计算出索引为 7 所以,ThreadLocal2 存储在索引为 7 的位置
  • 同理对于 ThreadLocal3,计算出下标位 11

image.png

🔑3. ThreadLocalMap扩容?
  • ThreadLocalMap 的 capacity 为 16
  • ThreadLocalMap 的 扩容因子 为 2/3

因此大概在什么时候发生扩容?

  • 16 * 2/3 =10.6
  • 大约在第 10 个元素时,发生扩容,容量翻倍

若当前容量为16,则插入第 10 个元素时候,会发生扩容,扩容后容量为之前两倍,且会重新计算索引
image.png

  • ThreadLocalMap 扩容时,它的容量(即内部数组的大小)增加,通常是翻倍。由于哈希表的索引是通过哈希码与当前容量相关的运算得到的,增加容量后,原有元素的索引可能会发生变化。这是因为索引计算通常涉及到哈希码与容量的某种运算(如模运算),容量的改变意味着这个运算的结果也可能改变。
  • 为了保持哈希表的正确性和效率,扩容后需要重新计算所有元素的索引,并将它们放置到正确的位置。这个过程称为“重新哈希”(rehashing)。重新哈希确保了元素在新的内部数组中仍然按照其哈希码分布,同时也解决了由于容量增加而可能导致的哈希冲突减少的情况。

3-3 ThreadLocalMap如何解决哈希冲突?

  • HashMap、ConcurrentHashMap、HashTable 都是使用拉链法解决哈希冲突
  • ThreadLocalMap使用的开放寻址法来解决哈希冲突

例如对于上述插入结果,如果再新加入一个 ThreadLocal11,固定哈希码从 0 开始,此时发现 0 位置被 ThreadLocal1占用,此时会寻找下一个地址,即寻找到 1 的位置,因此 ThreadLocal11 会插入到 索引为 1 的位置。
image.png


4- ThreadLocalMap 键的弱引用

image.png

  • 可以看到如下 ThreadLocalMap的源码,键和值为一个 Entry 类型
  • Entry 继承了 弱引用,并在构造中调用 super,因此 key 是一个弱引用类型
static class Entry extends WeakReference<ThreadLocal<?>>
  • Entry的构造函数
Entry(ThreadLocal<?> k, Object v) {
    super(k);
    value = v;
}
🔑为什么ThreadLocal的key设计成弱引用?
  • ① Thread 可能需要长时间运行(如线程池中的线程),如果 key 不再使用,需要在内存不足(GC)时释放其占用的内存
  • ② 但 GC 仅是让 key 的内存释放,后续还要根据 key 是否为 null 来进一步释放内存
    • 获取 key 发现 null key
    • set key 时,会使用启发式扫描,清除临近的 null key,启发次数与元素个数,是否发现 null key 有关
    • remove时(推荐),因为一般使用 ThreadLocal 时都把它作为静态变量,因此 GC 无法回收

5- ThreadLocal 中 value 内存回收

  • 假设有如下场景,ThreadLocal中的 key 被 GC (用黑色表示key内存被释放了),而此时 三个 value值还存在,则值释放的场景有三种

image.png

❌1.值回收场景1:get(不推荐)
  • 获取 key 发现 null key,此时对应的内存也会被释放,比如 get操作执行到 索引 7 的位置此时发现 7 位置的 key 为null,此时会释放掉 value2的内存,同时会放进去一个新 key

image.png

❌2.值回收场景2:set(不推荐)
  • set key 时,会使用启发式扫描,清除临近的 null key,启发次数与元素个数,是否发现 null key 有关
  • 启发式是指
    • ① 如果元素个数多,则扫描范围大一点
    • ② 是否发现 null key,如果发现 null key 则扫描范围大一点

get 方法和 set方法有局限性

  • get方法:当调用get方法时,如果对应的ThreadLocal对象已经被回收,ThreadLocalMap中的条目的键会是null。虽然get方法会检查并清理掉这些键为null的条目,但如果不频繁调用get方法,这些条目就会一直存在,占用内存。
  • set方法:set方法在添加新的线程局部变量时,会尝试清理已经被回收的ThreadLocal对象的条目(键为null的条目)。然而,如果一个线程不再设置新的线程局部变量,那么这种清理机制就不会被触发。

总结来说,虽然get和set方法在一定程度上可以减轻内存泄漏的问题(通过清理键为null的条目),但它们不能完全解决问题,因为它们依赖于对ThreadLocal变量的频繁访问。只有通过显式调用remove方法,才能确保ThreadLocalMap中相关的条目被及时清理,从而避免内存泄漏。

🔑3.值回收场景3:remove 防止内存泄漏
  • ThreadLocalMap中使用的 key 为 ThreadLocal 的弱引用,而 value 是强引用。所以,如果 ThreadLocal 没有被外部强引用的情况下,在垃圾回收的时候,key 会被清理掉,而 value 不会被清理掉。
  • 这样一来,ThreadLocalMap 中就会出现 keynull 的 Entry。假如我们不做任何措施的话,value 永远无法被 GC 回收,这个时候就可能会产生内存泄露。
  • ThreadLocalMap实现中已经考虑了这种情况,在调用 set()get()remove() 方法的时候,会清理掉 key 为 null 的记录。使用完 ThreadLocal方法后最好手动调用remove()方法

补充知识

Java中的弱引用和强引用

  1. 强引用(Strong Reference)
  • 强引用是Java中最常见的引用类型。如果一个对象具有强引用,垃圾回收器绝不会回收它。当内存空间不足时,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会回收这种对象。
  • 只要obj引用存在,所指向的对象就不会被回收。
Object obj = new Object(); // obj是一个强引用
  1. 软引用(Soft Reference)
  • 软引用是用来描述一些还有用但非必需的对象。在系统将要发生内存溢出异常之前,会把这些对象列入回收范围之中进行第二次回收。如果这次回收还没有足够的内存,才会抛出内存溢出异常。
  • 软引用可以用来实现内存敏感的高速缓存。
Object obj = new Object();
SoftReference<Object> softRef = new SoftReference<Object>(obj);
obj = null; // 取消强引用
  1. 弱引用(Weak Reference)
  • 弱引用也是用来描述非必需对象的,但是其强度比软引用更弱一些,被弱引用关联对象只能生存到下一次垃圾回收发生之前。当垃圾回收器工作时,无论当前内存空间足够与否,都会回收掉只被弱引用关联的对象。
  • 弱引用通常用于实现规范映射(Canonicalizing mappings)等,例如WeakHashMap。
Object obj = new Object();
WeakReference<Object> weakRef = new WeakReference<Object>(obj);
obj = null; // 取消强引用

ThreadLocal的弱引用

  • 当一个类的构造器中调用了super(k),并且这个类是WeakReference的子类,这意味着这个类在构造时将传入的对象 k 作为一个弱引用来处理。
  • 因此在 ThreadLocalMap 源码中的 key 是一个弱引用
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值