ThreadLocal（线程本地存储）

什么是 ThreadLocal？

ThreadLocal 是 Java 中用于实现线程本地存储的一个类。它的主要作用是为每个线程提供独立的变量副本，从而避免多线程环境下的数据共享和竞争问题。

• ThreadLocal 是一个工具类，允许你为每个线程创建独立的变量副本。
• 每个线程访问 ThreadLocal 变量时，都会获取到属于该线程的独立副本，其他线程无法访问或修改这个副本。
• 它的核心思想是：线程隔离。

使用场景

ThreadLocal 通常用于以下场景：

1. 避免线程安全问题：
   • 在多线程环境下，某些变量需要在线程间隔离，避免共享导致的竞争条件。
2. 保存线程上下文信息：
   • 比如在 Web 应用中，使用 ThreadLocal 保存用户请求的上下文（如用户 ID、事务信息等）。
3. 替代参数传递：
   • 当某些方法需要频繁传递同一个对象时，可以用 ThreadLocal 简化代码逻辑。

工作原理

ThreadLocal 的核心机制如下：

1. 每个线程都有一个 ThreadLocalMap，用于存储该线程的所有 ThreadLocal 变量。
2. 当线程访问 ThreadLocal 的 get() 方法时，会从当前线程的 ThreadLocalMap 中查找对应的值。
3. 如果没有找到值，则调用 initialValue() 方法初始化一个新值，并将其存储到 ThreadLocalMap 中。

基本用法

示例 1：基本使用

public class ThreadLocalExample {// 创建一个 ThreadLocal 变量private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);public static void main(String[] args) {Runnable task = () -> {// 获取当前线程的变量副本Integer value = threadLocal.get();System.out.println(Thread.currentThread().getName() + " 初始值: " + value);// 修改变量值threadLocal.set(value + 1);System.out.println(Thread.currentThread().getName() + " 修改后值: " + threadLocal.get());};// 创建多个线程Thread t1 = new Thread(task, "线程 1");Thread t2 = new Thread(task, "线程 2");t1.start();t2.start();}
}

输出结果：

线程 1 初始值: 0
线程 2 初始值: 0
线程 1 修改后值: 1
线程 2 修改后值: 1

说明：

• 每个线程都有独立的变量副本，互不干扰。
• 即使两个线程操作同一个 ThreadLocal 对象，它们的值也是隔离的。

---

示例 2：在线程池中的使用

由于线程池中的线程会被复用，使用 ThreadLocal 时需要注意清理变量，否则可能导致内存泄漏。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class ThreadLocalWithThreadPool {private static ThreadLocal<String> threadLocal = new ThreadLocal<>();public static void main(String[] args) {ExecutorService pool = Executors.newFixedThreadPool(2);for (int i = 0; i < 5; i++) {int taskId = i;pool.submit(() -> {try {// 设置线程本地变量threadLocal.set("任务 " + taskId);System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());} finally {// 清理线程本地变量threadLocal.remove();}});}pool.shutdown();}
}

输出结果（顺序可能不同）：

pool-1-thread-1: 任务 0
pool-1-thread-2: 任务 1
pool-1-thread-1: 任务 2
pool-1-thread-2: 任务 3
pool-1-thread-1: 任务 4

注意：

• 必须在任务结束时调用 threadLocal.remove() 清理变量，避免线程复用时出现脏数据。

ThreadLocal 的优缺点

优点

1. 线程隔离：
   • 每个线程都有独立的变量副本，避免了多线程间的竞争和同步问题。
2. 简化代码：
   • 不需要通过参数传递共享变量，减少了代码复杂度。

缺点

1. 内存泄漏风险：
   • 如果不及时清理 ThreadLocal 变量，可能会导致内存泄漏，尤其是在使用线程池时。
2. 不适合所有场景：
   • ThreadLocal 适用于线程隔离的场景，但不适合需要线程间共享数据的场景。

内存泄漏问题

ThreadLocal 的内存泄漏问题主要源于以下原因：

1. 强引用链：
   • Thread → ThreadLocalMap → Entry（键为 ThreadLocal 引用，值为变量副本）。
2. 未清理的变量：
   • 如果 ThreadLocal 对象被回收，但 ThreadLocalMap 中的 Entry 仍然持有对值的强引用，可能导致内存泄漏。

解决方案：

• 在使用完 ThreadLocal 后，务必调用 remove() 方法清理变量。

总结

特性	描述
用途	为每个线程提供独立的变量副本，避免线程间共享数据的问题。
优点	线程隔离、简化代码逻辑。
缺点	存在内存泄漏风险，必须手动清理变量。
典型场景	用户请求上下文、数据库连接管理、事务管理等需要线程隔离的场景。

实际开发中的主要应用场景

1. 用户请求上下文（Web 应用）

在 Web 应用中，每个用户的请求通常由一个独立的线程处理。为了在整个请求生命周期中保持用户相关的上下文信息（如用户 ID、事务信息等），可以使用 ThreadLocal。

示例场景：

• 保存用户登录信息：
  每个线程处理一个用户的请求时，可以将用户的登录信息存储在 ThreadLocal 中，避免在方法间频繁传递参数。

public class UserContext {private static ThreadLocal<String> currentUser = new ThreadLocal<>();public static void setCurrentUser(String username) {currentUser.set(username);}public static String getCurrentUser() {return currentUser.get();}public static void clear() {currentUser.remove();}
}// 使用示例
public class RequestHandler {public void handleRequest() {try {// 设置当前用户UserContext.setCurrentUser("Alice");System.out.println("当前用户: " + UserContext.getCurrentUser());// 处理业务逻辑...} finally {// 清理上下文UserContext.clear();}}
}

2. 数据库连接管理

在多线程环境下，数据库连接通常是有限的资源。为了避免多个线程共享同一个数据库连接，可以为每个线程分配独立的连接，并通过 ThreadLocal 管理。

示例场景：

• 每个线程独享一个数据库连接：
  使用 ThreadLocal 存储线程专属的数据库连接对象，确保线程安全。

import java.sql.Connection;
import java.sql.DriverManager;public class ConnectionManager {private static ThreadLocal<Connection> threadLocalConnection = ThreadLocal.withInitial(() -> {try {return DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "password");} catch (Exception e) {throw new RuntimeException("获取数据库连接失败", e);}});public static Connection getConnection() {return threadLocalConnection.get();}public static void closeConnection() {Connection connection = threadLocalConnection.get();if (connection != null) {try {connection.close();} catch (Exception e) {e.printStackTrace();}}threadLocalConnection.remove(); // 清理连接}
}// 使用示例
public class DatabaseService {public void executeQuery() {Connection conn = ConnectionManager.getConnection();try {// 执行 SQL 查询...} finally {ConnectionManager.closeConnection();}}
}

3. 事务管理

在分布式系统或复杂业务逻辑中，事务管理需要贯穿整个方法调用链。通过 ThreadLocal，可以在线程范围内维护事务状态，确保事务的一致性。

示例场景：

• 事务上下文管理：
  在一个事务中，所有方法都可以访问同一个事务上下文，而无需显式传递事务对象。

public class TransactionContext {private static ThreadLocal<Boolean> inTransaction = ThreadLocal.withInitial(() -> false);public static void beginTransaction() {inTransaction.set(true);System.out.println("事务已开启");}public static boolean isInTransaction() {return inTransaction.get();}public static void commit() {if (isInTransaction()) {System.out.println("事务已提交");inTransaction.remove();}}public static void rollback() {if (isInTransaction()) {System.out.println("事务已回滚");inTransaction.remove();}}
}// 使用示例
public class TransactionService {public void performTransaction() {TransactionContext.beginTransaction();try {// 执行业务逻辑...System.out.println("执行事务操作");TransactionContext.commit();} catch (Exception e) {TransactionContext.rollback();}}
}

4. 避免线程安全问题

在某些情况下，类中的变量可能需要被多个方法访问，但又不希望这些变量被多个线程共享。可以通过 ThreadLocal 实现线程隔离。

示例场景：

• SimpleDateFormat 的线程安全问题：
  SimpleDateFormat 是非线程安全的，但如果每个线程都有自己的 SimpleDateFormat 实例，就可以避免线程安全问题。

import java.text.SimpleDateFormat;
import java.util.Date;public class DateFormatUtil {private static ThreadLocal<SimpleDateFormat> threadLocalDateFormat = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));public static String formatDate(Date date) {return threadLocalDateFormat.get().format(date);}
}// 使用示例
public class DateFormatExample {public static void main(String[] args) {Date now = new Date();System.out.println(DateFormatUtil.formatDate(now));}
}

5. 日志追踪

在分布式系统中，为了追踪某个请求的完整调用链路，可以使用 ThreadLocal 存储唯一的请求 ID（Trace ID）。这样，在整个请求处理过程中，所有的日志都会带上这个 Trace ID。

示例场景：

• 日志上下文管理：
  在每个线程中存储唯一的 Trace ID，用于日志记录。

public class LogContext {private static ThreadLocal<String> traceId = new ThreadLocal<>();public static void setTraceId(String id) {traceId.set(id);}public static String getTraceId() {return traceId.get();}public static void clear() {traceId.remove();}
}// 使用示例
public class Logger {public static void log(String message) {String traceId = LogContext.getTraceId();System.out.println("[" + traceId + "] " + message);}
}// 请求处理
public class RequestHandler {public void handleRequest() {try {LogContext.setTraceId("TRACE-12345");Logger.log("开始处理请求");// 处理业务逻辑...Logger.log("请求处理完成");} finally {LogContext.clear();}}
}

总结

ThreadLocal 的主要应用场景包括：

1. 用户请求上下文：存储用户会话信息。
2. 数据库连接管理：为每个线程分配独立的数据库连接。
3. 事务管理：维护事务上下文。
4. 避免线程安全问题：为每个线程提供独立的对象实例。
5. 日志追踪：为每个请求生成唯一的 Trace ID。