ThreadLocal 详解

1. 使用try-finally块确保清理：

try {
    threadLocal.set(value);
    // 业务逻辑...
} finally {
    threadLocal.remove(); // 就像用完厕所要冲水！
}

2. 线程池环境下的清理：

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(() -> {
    try {
        threadLocal.set(value);
        // 任务逻辑
    } finally {
        threadLocal.remove(); // 必须清理！
    }
});

Thread类中的关键变量：

每个Thread对象内部都维护一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个变量就是线程本地变量的存储容器。在Thread类的源码中可以看到：

public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
    // 其他代码...
}

这个设计的核心思想是：每个线程拥有自己的ThreadLocalMap，用于存储该线程的所有ThreadLocal变量。这种设计确保了线程间的数据隔离，每个线程只能访问自己的ThreadLocalMap，无法访问其他线程的。

ThreadLocalMap的结构：

ThreadLocalMap是ThreadLocal的静态内部类，它本质上是一个定制化的哈希表。其核心结构如下：

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        Object value;
        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
    
    private Entry[] table;
    // 其他代码...
}

这里有两个关键要点：

• Entry继承自WeakReference<ThreadLocal<?>>，这意味着Entry的key（ThreadLocal实例）是弱引用
• 每个Entry存储一个键值对，key是ThreadLocal实例，value是线程本地变量的值

存储关系的完整视图：

线程Thread
  ↳ threadLocals（ThreadLocalMap类型）
      ↳ table（Entry数组）
          ↳ Entry（key=ThreadLocal实例（弱引用），value=线程本地变量）

set(T value)方法的执行流程：

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        map.set(this, value); // 使用当前ThreadLocal实例作为Key
    } else {
        createMap(t, value);
    }
}

get()方法的执行流程：

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

createMap方法：

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

createMap方法会创建一个新的ThreadLocalMap，并将当前ThreadLocal实例和初始值作为第一个Entry存入。

为什么使用弱引用？

使用弱引用的设计是"最后一道防线"：当外部强引用消失后，下次GC会回收ThreadLocal对象。这样可以避免ThreadLocal对象本身的泄漏。

弱引用带来的问题

set操作中的哈希冲突处理：

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    
    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        
        if (k == key) {
            e.value = value;
            return;
        }
        
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    
    tab[i] = new Entry(key, value);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

get操作中的哈希冲突处理：

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

如果初始位置的Entry不是目标Entry，会调用getEntryAfterMiss方法进行线性探测，直到找到目标Entry或遇到null。

数据库连接管理的实现原理：

每个线程通过ThreadLocal持有独立的数据库连接，确保线程安全。在涉及到数据库连接的嵌套调用场景中，ThreadLocal可以用来确保每个线程都有自己的数据库连接，避免连接共享带来的问题，保证事务的一致性。

具体实现示例：

public class ConnectionManager {
    private static final ThreadLocal<Connection> connHolder = new ThreadLocal<>();
    
    public static Connection getConnection() throws SQLException {
        Connection conn = connHolder.get();
        if (conn == null || conn.isClosed()) {
            conn = DriverManager.getConnection(DB_URL);
            connHolder.set(conn);
        }
        return conn;
    }
    
    public static void closeConnection() throws SQLException {
        Connection conn = connHolder.get();
        if (conn != null) {
            conn.close();
            connHolder.remove(); // 关键的清理操作
        }
    }
}

这个示例展示了如何使用ThreadLocal管理数据库连接：

1. 每个线程首次调用getConnection()时创建连接
2. 后续调用直接使用保存在ThreadLocal中的连接
3. 连接使用完毕后调用closeConnection()关闭连接并清理ThreadLocal

事务管理中的应用：

在Spring等框架中，ThreadLocal被广泛用于事务管理。Spring的事务管理通过ThreadLocal存储数据库连接，保证同一个事务中使用同一个数据库连接。

public class TransactionManager {
    private static final ThreadLocal<Connection> txHolder = new ThreadLocal<>();
    
    public static void beginTransaction() throws SQLException {
        Connection conn = getConnection();
        txHolder.set(conn);
        conn.setAutoCommit(false);
    }
    
    public static void commitTransaction() throws SQLException {
        Connection conn = txHolder.get();
        if (conn != null) {
            conn.commit();
            conn.setAutoCommit(true);
            txHolder.remove();
        }
    }
    
    public static void rollbackTransaction() throws SQLException {
        Connection conn = txHolder.get();
        if (conn != null) {
            conn.rollback();
            conn.setAutoCommit(true);
            txHolder.remove();
        }
    }
}

Web应用中的用户会话管理：

在Web框架中，ThreadLocal常用于存储当前请求的用户上下文，如用户ID、权限信息、语言环境等。每个HTTP请求由独立的线程处理，通过ThreadLocal可以轻松实现会话数据的线程隔离。

public class SessionContext {
    private static final ThreadLocal<String> userIdHolder = new ThreadLocal<>();
    private static final ThreadLocal<String> languageHolder = new ThreadLocal<>();
    
    public static void setUserId(String userId) {
        userIdHolder.set(userId);
    }
    
    public static String getUserId() {
        return userIdHolder.get();
    }
    
    public static void setLanguage(String language) {
        languageHolder.set(language);
    }
    
    public static String getLanguage() {
        return languageHolder.get();
    }
    
    public static void clear() {
        userIdHolder.remove();
        languageHolder.remove();
    }
}

在Servlet过滤器或Spring拦截器中，可以在请求开始时设置用户信息，请求结束时清理：

public class SessionFilter implements Filter {
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        try {
            // 从请求中获取用户ID和语言信息
            String userId = request.getHeader("X-User-Id");
            String language = request.getHeader("X-Language");
            
            SessionContext.setUserId(userId);
            SessionContext.setLanguage(language);
            
            chain.doFilter(request, response);
        } finally {
            SessionContext.clear(); // 确保清理
        }
    }
}

分布式系统中的请求上下文：

在微服务架构中，一个请求通常会穿越多个服务或线程。ThreadLocal常用于存储请求上下文信息，如用户认证信息、追踪日志ID等。

public class RequestContext {
    private static final ThreadLocal<String> traceIdHolder = new ThreadLocal<>();
    private static final ThreadLocal<Map<String, String>> headersHolder = new ThreadLocal<>();
    
    public static void setTraceId(String traceId) {
        traceIdHolder.set(traceId);
    }
    
    public static String getTraceId() {
        return traceIdHolder.get();
    }
    
    public static void setHeaders(Map<String, String> headers) {
        headersHolder.set(new HashMap<>(headers));
    }
    
    public static Map<String, String> getHeaders() {
        return headersHolder.get();
    }
}

生成和传递追踪ID：

在分布式调用链中，为每个请求生成唯一的追踪ID，在日志中统一打印追踪ID，便于调试和追踪问题。

public class TraceIdGenerator {
    private static final ThreadLocal<String> traceIdHolder = new ThreadLocal<>();
    
    public static String generateTraceId() {
        String traceId = UUID.randomUUID().toString();
        traceIdHolder.set(traceId);
        return traceId;
    }
    
    public static String getTraceId() {
        String traceId = traceIdHolder.get();
        if (traceId == null) {
            traceId = generateTraceId();
        }
        return traceId;
    }
}

日志记录器的集成：

在日志记录中，可以存储一些线程相关的上下文信息，例如线程ID、请求ID等，方便排查问题。通过为每个线程设置独立的日志上下文，日志信息更加清晰，便于开发者追踪每个线程的执行过程，快速定位问题。

public class LogContext {
    private static final ThreadLocal<String> traceId = new ThreadLocal<>();
    private static final ThreadLocal<String> userId = new ThreadLocal<>();
    
    public static void setTraceId(String traceId) {
        LogContext.traceId.set(traceId);
    }
    
    public static void setUserId(String userId) {
        LogContext.userId.set(userId);
    }
    
    public static String getLogMessagePrefix() {
        return String.format(
            "[traceId=%s, userId=%s, thread=%s]",
            traceId.get() != null ? traceId.get() : "N/A",
            userId.get() != null ? userId.get() : "N/A",
            Thread.currentThread().getName()
        );
    }
}

使用示例：

public class SomeService {
    public void someMethod() {
        String prefix = LogContext.getLogMessagePrefix();
        System.out.println(prefix + " 进入someMethod方法");
        
        // 业务逻辑...
        
        System.out.println(prefix + " 退出someMethod方法");
    }
}

SimpleDateFormat的线程安全问题：

SimpleDateFormat是典型的非线程安全类。当线程池开启，提交大量任务时，每个线程都创建属于自己的SimpleDateFormat开销会很大，而且占用内存。使用synchronized加锁可以解决线程安全问题，但会发生阻塞，影响效率。

使用ThreadLocal的解决方案：

public class DateFormatUtil {
    private static final ThreadLocal<SimpleDateFormat> dateFormatHolder = 
        ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    
    public static String formatDate(Date date) {
        return dateFormatHolder.get().format(date);
    }
    
    public static Date parseDate(String dateStr) throws ParseException {
        return dateFormatHolder.get().parse(dateStr);
    }
}

其他非线程安全类的应用：

除了SimpleDateFormat，类似的非线程安全类还包括：

• Random类（线程安全版本为ThreadLocalRandom）
• 各种Parser类（如XMLParser、JSONParser）
• 一些第三方工具类