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。