深入解析ThreadLocal：线程隔离利器

发布于：2025-07-15 ⋅ 阅读:(16) ⋅ 点赞:(0)

目录

1.ThreadLocal的定义

核心特点：

2.ThreadLocal解决的核心问题

2.1 线程安全问题

2.2 跨方法传递上下文

3.ThreadLocal的数据结构

3.1 核心组件

3.2 内存结构关系

4.LocalThread代码示例

4.ThreadLocal弱引用

4.1java的四种引用类型

4.2GC之后key是否为null？

4.3解决方案

1.ThreadLocal的定义

ThreadLocal 是 Java 中的一个类，用于创建线程局部变量。每个使用该变量的线程都拥有独立的副本，线程间无法相互访问对方的副本，从而实现数据的线程隔离。

核心特点：

  • 每个线程拥有自己的独立副本

  • 存储与获取数据无需同步，避免线程安全问题

  • 常用于存储线程上下文信息（如用户会话、事务 ID）

2.ThreadLocal解决的核心问题

        ThreadLocal是一个线程域对象在业务当中，每一个请求到达微服务对象时都是一个独立的线程。如果不保存到Threadlocal中就会出现多线程并发修改的安全问题。而Threadlocal会将这些信息保存到线程内部并且每个线程之间都可以做到互不干扰

2.1 线程安全问题

通过为每个线程提供独立的变量副本，避免多线程竞争共享资源。

// 线程不安全的实现
public class UnsafeCounter {
    private int count = 0;
    
    public void increment() {
        count++; // 非原子操作，多线程下有竞态条件
    }
}

// 使用ThreadLocal的线程安全实现
public class SafeCounter {
    private ThreadLocal<Integer> count = ThreadLocal.withInitial(() -> 0);
    
    public void increment() {
        count.set(count.get() + 1); // 每个线程操作自己的副本
    }
}

2.2 跨方法传递上下文

避免通过方法参数层层传递数据，提高代码简洁性。

// 使用ThreadLocal存储用户会话
public class UserContextHolder {
    private static final ThreadLocal<UserSession> session = new ThreadLocal<>();
    
    public static void setSession(UserSession s) {
        session.set(s);
    }
    
    public static UserSession getSession() {
        return session.get();
    }
    
    public static void clear() {
        session.remove();
    }
}

// 在任意方法中可直接获取当前线程的会话
public void processRequest() {
    UserSession current = UserContextHolder.getSession();
    // 使用会话信息...
}

3.ThreadLocal的数据结构

3.1 核心组件

ThreadLocal 的实现依赖三个关键组件：

  • Thread 类：每个线程包含一个ThreadLocal.ThreadLocalMap类型的threadLocals字段

  • ThreadLocalMap：自定义哈希表，存储线程的所有局部变量

  • ThreadLocal：作为键（Key），用于在 ThreadLocalMap 中定位值

3.2 内存结构关系

        Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

        ThreadLocalMap有自己的独立实现，可以简单地将它的key视作ThreadLocal，value为代码中放入的值（实际上key并不是ThreadLocal本身，而是它的一个弱引用）。

        每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

        ThreadLocalMap有点类似HashMap的结构，只是HashMap是由数组+链表实现的，而ThreadLocalMap中并没有链表结构。

        我们还要注意Entry， 它的key是ThreadLocal k ，继承自WeakReference， 也就是我们常说的弱引用类型。

4.LocalThread代码示例

import java.util.ArrayList;
import java.util.List;

public class ThreadLocalTest {
    private List<String> messages = new ArrayList<>();

    public static final ThreadLocal<ThreadLocalTest> holder = ThreadLocal.withInitial(ThreadLocalTest::new);

    public static void add(String message) {
        holder.get().messages.add(message);
    }

    public static List<String> clear() {
        List<String> messages = holder.get().messages;
        holder.remove();

        System.out.println("size: " + holder.get().messages.size());
        return messages;
    }

    public static void main(String[] args) {
        ThreadLocalTest.add("11");
        System.out.println(holder.get().messages);
        ThreadLocalTest.add("22");
        System.out.println(holder.get().messages);
        ThreadLocalTest.add("33");
        System.out.println(holder.get().messages);

        for (int i = 0; i < 10; i++){
            int finalI = i;
            new Thread(() -> {
                ThreadLocalTest.add("number:"+ finalI);
                System.out.println(holder.get().messages);
            }).start();
        }

    }
}

运行结果如下：

分析上面的代码：

public static final ThreadLocal holder = ThreadLocal.withInitial(ThreadLocalTest::new);

public static final：表明该holder是唯一的，并且所有线程共用这一个holder——可以理解为是一个全局标签

ThreadLocal：说明这个ThreadLocal专门用来存ThreadLocalTest类型的对象

ThreadLocal.withInitial(ThreadLocalTest::new):这是初始化规则，意思是 “当线程第一次用这个 holder 时，自动创建一个新的 ThreadLocalTest 对象”（ThreadLocalTest::new 就是调用 ThreadLocalTest 的无参构造方法）

holder.get().messages.add(message);

holder.get():

  1. 获取当前线程的 ThreadLocalMap。

  2. 以 holder 为标签，在当前线程的仓库里查找对应的 ThreadLocalTest 对象。

  3. 如果是第一次调用，会触发 withInitial() 里的初始化逻辑（创建新的 ThreadLocalTest 实例）。

.messages.add(message):messages 是 ThreadLocalTest 类中的一个 List 类型的成员变量,每个 ThreadLocalTest 实例都有自己的 messages 列表。向当前线程的 messages 列表中添加一个新的字符串元素。

holder 就像一个 “全局标签”（唯一），每个线程第一次用它时，会自动生成一个属于自己的 ThreadLocalTest 实例，之后每次用这个标签，都能拿到自己的实例，线程之间互不干扰。

4.ThreadLocal弱引用

4.1java的四种引用类型

引用类型

特性

强引用

最常见的引用类型，如Object obj = new Object()，只要强引用存在，对象不会被 GC

软引用

用SoftReference包装，在内存不足时会被 GC 回收，常用于缓存

弱引用

用WeakReference包装，每次 GC 时都会被回收，ThreadLocalMap 的键使用弱引用

虚引用

用PhantomReference包装，无法通过虚引用获取对象，仅用于对象被回收时的通知

4.2GC之后key是否为null？

 ThreadLocal 的key是弱引用，那么在ThreadLocal.get()的时候,发生GC之后，key是否是null？是的


public class ThreadLocalTest {

    public static void main(String[] args) {
        // 创建一个ThreadLocal
        new ThreadLocal<>().set("value");
        // 触发GC
        System.gc();

        // 此时Entry的key为null，但value仍存在
    }
}4

ThreadLocal 的 key 使用弱引用是为了 避免 ThreadLocal 对象本身的内存泄漏（当外部不再使用它时，GC 可以回收），但如果 value 对象的生命周期管理不当（如未手动调用 remove()），就会导致 value 泄漏。

4.3解决方案

1、set() 之后必须在 finally 块中调用 remove()，尤其是在线程池环境中。

ThreadLocal<String> threadLocal = new ThreadLocal<>();
try {
    threadLocal.set("value");
    // 使用 threadLocal...
} finally {
    threadLocal.remove(); // 关键！确保清理 Entry
}

2、通过创建一个强引用来指向弱引用所关联的对象，从而阻止该对象被 GC 回收。

public static void main(String[] args) {
    // 创建一个ThreadLocal
    ThreadLocal<Object> objectThreadLocal = new ThreadLocal<>();
    objectThreadLocal.set("value");
    // 触发GC
    System.gc();
    // 此时Entry的key为强引用，不会被回收
}

如果我们的强引用不存在的话，那么 key 就会被回收，也就是会出现们 value 没被回收，key 被回收，导致 value 永远存在，依旧会内存泄漏。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布