魔法狂暴内置菜单中文版
142.36MB · 2025-11-06
ThreadLocal 是 Java 中一个非常有用的类，它用于提供线程局部变量。这些变量与普通变量不同，每个访问该变量的线程都有自己独立初始化的变量副本，从而实现了线程之间的数据隔离。
它的核心价值在于：将状态（例如，用户 ID、事务 ID）与线程关联起来，使得在一个线程的整个执行路径上，可以轻松访问这个状态，而无需显式地传递参数，同时避免了线程安全问题。
这是 ThreadLocal 最经典的应用场景，尤其在 Spring 等框架中。
场景描述：在 Web 应用中，一个请求通常对应一个线程。为了保证事务的原子性，整个业务逻辑处理过程中必须使用同一个数据库连接。如果多次从连接池获取连接，可能会得到不同的连接，导致无法提交或回滚事务。
解决方案：使用 ThreadLocal 来存储当前线程的数据库连接和事务上下文。
ThreadLocal 变量中。ThreadLocal 中获取连接，而不是重新申请。ThreadLocal 中移除连接，并将其释放回连接池。代码示例
public class ConnectionManager {
// 使用ThreadLocal保存数据库连接
private static final ThreadLocal<Connection> connectionHolder = new ThreadLocal<>();
// 获取数据源（实际应用中可能通过依赖注入获取）
private static DataSource dataSource; // 假设已初始化
/**
* 获取当前线程的数据库连接
*/
public static Connection getConnection() throws SQLException {
Connection conn = connectionHolder.get();
if (conn == null || conn.isClosed()) {
conn = dataSource.getConnection();
connectionHolder.set(conn);
}
return conn;
}
/**
* 将连接与当前线程解绑，并关闭连接
*/
public static void closeConnection() throws SQLException {
Connection conn = connectionHolder.get();
if (conn != null && !conn.isClosed()) {
connectionHolder.remove(); // 解除绑定
conn.close(); // 关闭连接
}
}
/**
* 开启事务
*/
public static void beginTransaction() throws SQLException {
Connection conn = getConnection();
conn.setAutoCommit(false);
}
/**
* 提交事务
*/
public static void commitTransaction() throws SQLException {
Connection conn = getConnection();
if (conn != null && !conn.getAutoCommit()) {
conn.commit();
conn.setAutoCommit(true); // 恢复自动提交模式
}
}
/**
* 回滚事务
*/
public static void rollbackTransaction() {
try {
Connection conn = getConnection();
if (conn != null && !conn.getAutoCommit()) {
conn.rollback();
conn.setAutoCommit(true); // 恢复自动提交模式
}
} catch (SQLException e) {
// 处理异常
}
}
}
// 使用示例
public class UserService {
public void createUser(User user) {
try {
ConnectionManager.beginTransaction();
// 执行数据库操作，所有操作使用同一连接
UserDao userDao = new UserDao();
userDao.insert(user);
// 其他数据库操作...
ConnectionManager.commitTransaction();
} catch (Exception e) {
ConnectionManager.rollbackTransaction();
throw new RuntimeException("Transaction failed", e);
} finally {
try {
ConnectionManager.closeConnection();
} catch (SQLException e) {
// 处理关闭连接异常
}
}
}
}
好处：
Spring 框架中的 TransactionSynchronizationManager 就大量使用了 ThreadLocal 来管理资源（如 DataSource、Connection）和事务同步状态。
在 Web 开发中，每个用户请求通常都携带一个唯一的 Session ID 来标识用户状态。
场景描述：在处理请求的各个层级（如控制器 Controller、服务层 Service、数据层 Dao）中，经常需要获取当前登录用户的信息（如用户 ID、用户名、权限等）。
解决方案：在拦截器或过滤器中，一旦通过 Session ID 验证了用户身份，就可以将用户信息（或整个 Session 对象）存入一个 ThreadLocal 中。
ThreadLocal 中获取用户信息，而无需每次都从 HttpSession 中读取。代码示例
public class UserContext {
// 存储当前登录用户信息
private static final ThreadLocal<User> currentUser = new ThreadLocal<>();
public static void setCurrentUser(User user) {
currentUser.set(user);
}
public static User getCurrentUser() {
return currentUser.get();
}
public static void clear() {
currentUser.remove();
}
}
// 用户信息类
public class User {
private Long id;
private String username;
private String role;
// 其他字段和getter/setter...
}
// 在过滤器或拦截器中设置用户信息
public class AuthenticationFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
try {
HttpServletRequest httpRequest = (HttpServletRequest) request;
// 从Session或Token中获取用户信息
User user = authenticate(httpRequest);
// 将用户信息存入ThreadLocal
UserContext.setCurrentUser(user);
chain.doFilter(request, response);
} finally {
// 确保请求结束后清理ThreadLocal，防止内存泄漏
UserContext.clear();
}
}
private User authenticate(HttpServletRequest request) {
// 实现认证逻辑，返回用户信息
// 示例中返回模拟用户
User user = new User();
user.setId(1L);
user.setUsername("john_doe");
user.setRole("ADMIN");
return user;
}
}
// 在业务层使用用户信息
public class OrderService {
public Order createOrder(Order order) {
// 直接从ThreadLocal获取当前用户，无需传递参数
User currentUser = UserContext.getCurrentUser();
if (currentUser == null) {
throw new SecurityException("User not authenticated");
}
order.setUserId(currentUser.getId());
order.setCreatedBy(currentUser.getUsername());
// 创建订单的业务逻辑...
return order;
}
}
好处：
createOrder(Order order)，而不是 createOrder(Order order, User user)。在一些复杂的调用链中，需要传递一些全局性的上下文信息。
ThreadLocal 中。之后，在任何需要记录日志的地方，日志组件（如重写的 Logback/Log4j 的 Appender）都可以从 ThreadLocal 中获取这个 Trace ID 并输出到日志中。public class TraceContext {
// 存储跟踪ID
private static final ThreadLocal<String> traceIdHolder = new ThreadLocal<>();
public static void setTraceId(String traceId) {
traceIdHolder.set(traceId);
}
public static String getTraceId() {
String traceId = traceIdHolder.get();
if (traceId == null) {
// 如果没有设置跟踪ID，生成一个新的
traceId = generateTraceId();
setTraceId(traceId);
}
return traceId;
}
public static void clear() {
traceIdHolder.remove();
}
private static String generateTraceId() {
return UUID.randomUUID().toString().replace("-", "").substring(0, 16);
}
}
// 自定义日志Appender（以Logback为例）
public class TraceLogAppender extends ch.qos.logback.core.AppenderBase<ILoggingEvent> {
@Override
protected void append(ILoggingEvent event) {
// 获取当前线程的跟踪ID
String traceId = TraceContext.getTraceId();
// 将跟踪ID添加到日志消息中
String message = "[" + traceId + "] " + event.getFormattedMessage();
// 输出到控制台（实际应用中可能输出到文件或日志系统）
System.out.println(message);
}
}
// 在请求入口处设置跟踪ID
public class TraceFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
try {
HttpServletRequest httpRequest = (HttpServletRequest) request;
// 从请求头获取跟踪ID，如果没有则生成新的
String traceId = httpRequest.getHeader("X-Trace-Id");
if (traceId == null || traceId.isEmpty()) {
traceId = TraceContext.generateTraceId();
}
// 设置跟踪ID到ThreadLocal
TraceContext.setTraceId(traceId);
// 将跟踪ID添加到响应头，方便客户端追踪
((HttpServletResponse) response).setHeader("X-Trace-Id", traceId);
chain.doFilter(request, response);
} finally {
// 清理ThreadLocal
TraceContext.clear();
}
}
}
// 在业务代码中使用
public class PaymentService {
private static final Logger logger = LoggerFactory.getLogger(PaymentService.class);
public void processPayment(Payment payment) {
// 记录日志时会自动包含跟踪ID
logger.info("Processing payment: {}", payment.getId());
// 处理支付逻辑...
logger.info("Payment processed successfully: {}", payment.getId());
}
}
这是一个更通用的用法，可以看作是场景 2 和 3 的抽象。
ThreadLocal 中。顶层方法设置值，深层方法直接获取值，中间的无数层方法无需做任何修改。public class CompanyContext {
// 存储当前公司/租户ID
private static final ThreadLocal<Long> companyIdHolder = new ThreadLocal<>();
public static void setCompanyId(Long companyId) {
companyIdHolder.set(companyId);
}
public static Long getCompanyId() {
Long companyId = companyIdHolder.get();
if (companyId == null) {
throw new IllegalStateException("Company ID not set in context");
}
return companyId;
}
public static void clear() {
companyIdHolder.remove();
}
}
// 在请求处理开始时设置公司ID（例如在过滤器中）
public class CompanyFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
try {
HttpServletRequest httpRequest = (HttpServletRequest) request;
// 从请求中获取公司ID（可能来自子域名、请求头或用户信息）
Long companyId = extractCompanyId(httpRequest);
// 设置到ThreadLocal
CompanyContext.setCompanyId(companyId);
chain.doFilter(request, response);
} finally {
CompanyContext.clear();
}
}
private Long extractCompanyId(HttpServletRequest request) {
// 实现提取公司ID的逻辑
// 这里简单返回一个示例值
return 1001L;
}
}
// 业务服务类 - 无需传递companyId参数
public class ProductService {
private ProductDao productDao = new ProductDao();
public List<Product> getProductsByCategory(String category) {
// 直接从ThreadLocal获取公司ID
Long companyId = CompanyContext.getCompanyId();
// 查询特定公司的产品
return productDao.findByCompanyAndCategory(companyId, category);
}
public void addProduct(Product product) {
// 设置产品所属公司
product.setCompanyId(CompanyContext.getCompanyId());
// 保存产品
productDao.save(product);
}
}
// 数据访问对象 - 自动添加公司过滤条件
public class ProductDao {
public List<Product> findByCompanyAndCategory(Long companyId, String category) {
// 实际实现会使用JPA、MyBatis等ORM框架
String sql = "SELECT * FROM products WHERE company_id = ? AND category = ?";
// 执行查询...
return new ArrayList<>(); // 返回结果
}
public void save(Product product) {
// 保存产品实现...
}
}
虽然 ThreadLocal 很好用，但使用不当会导致严重问题，最主要的是内存泄漏。
内存泄漏风险：
ThreadLocal 变量是存储在每个线程的 ThreadLocalMap 中的。ThreadLocalMap 的 Key 是对 ThreadLocal 本身的弱引用（WeakReference） ，而 Value 是强引用。ThreadLocal 实例没有被外部强引用（例如，被设置为 null），在 GC 时，Key 会被回收，但 Value 不会。这就会导致一个 Key 为 null 而 Value 有值的 Entry 无法被访问，也无法被回收，造成内存泄漏。解决方案：
try...finally 块进行清理：在使用完 ThreadLocal 后，必须调用其 remove() 方法来清除当前线程的 Value。这是最佳实践，尤其是在使用线程池时（线程会被复用，如果不清理，会读到上一个请求的脏数据）。java
try {
threadLocal.set(someValue);
// ... 执行业务逻辑
} finally {
threadLocal.remove(); // 关键步骤！务必清理
}
设计考虑：通常将 ThreadLocal 变量声明为 private static final，以防止无意中创建多个实例，同时便于管理和清理。
| 应用场景 | 核心目的 | 典型案例 |
|---|---|---|
| 数据库连接与事务管理 | 保证一个线程内使用同一个连接和事务上下文 | Spring 事务管理 |
| 用户会话管理 | 避免在方法间显式传递用户信息，简化 API | 存储当前登录用户信息 |
| 全局上下文传递 | 在调用链的任意位置轻松获取上下文信息 | 全链路追踪的 Trace ID、国际化 |
| 避免传递冗余参数 | 保持方法签名干净，解耦中间方法 | 传递公司ID、租户ID等 |
核心思想：ThreadLocal 提供了一个线程级别的全局变量的优雅实现，它通过空间换时间（每个线程都有自己的副本）的方式，解决了多线程环境下共享变量的线程安全问题。但务必牢记使用后调用 remove() 以防内存泄漏。
