ThreadLocal 是 Java 中实现线程隔离的工具，每个线程拥有独立的变量副本。其核心基于 ThreadLocalMap 和 Entry 弱引用设计。常见用于 Web 请求上下文传递、数据库连接管理及避免参数冗余。主要风险在于线程池复用导致的内存泄漏，因 Key 为弱引用而 Value 为强引用。最佳实践是在 finally 块中调用 remove() 方法及时清理资源，或选用 TransmittableThreadLocal 解决线程池传递问题。
// 每个 Thread 对象内部都有一个 ThreadLocalMap
ThreadLocal.ThreadLocalMap threadLocals = null;
// ThreadLocalMap 内部使用 Entry 数组，Entry 继承自 WeakReference<ThreadLocal<?>>
static class Entry extends WeakReference<ThreadLocal<?>> {
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k); // 弱引用指向 ThreadLocal 实例
value = v; // 强引用指向实际存储的值
}
}
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
map.set(this, value); // this 指当前 ThreadLocal 实例
} else {
createMap(t, value);
}
}
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();
// 找到相同的 key，直接替换 value
if (k == key) {
e.value = value;
return;
}
// key 已被回收，替换过期条目
if (k == null) {
replaceStaleEntry(key, value, i);
return;
}
}
tab[i] = new Entry(key, value);
int sz = ++size;
// 清理并判断是否需要扩容
if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash();
}
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(); // 返回初始值
}
// 场景 1：线程上下文信息传递（如 Spring 的 RequestContextHolder）
public class RequestContextHolder {
private static final ThreadLocal<HttpServletRequest> requestHolder = new ThreadLocal<>();
public static void setRequest(HttpServletRequest request) {
requestHolder.set(request);
}
public static HttpServletRequest getRequest() {
return requestHolder.get();
}
}
// 场景 2：数据库连接管理
public class ConnectionManager {
private static ThreadLocal<Connection> connectionHolder = ThreadLocal.withInitial(() -> DriverManager.getConnection(url));
public static Connection getConnection() {
return connectionHolder.get();
}
}
// 场景 3：用户会话信息
public class UserContext {
private static ThreadLocal<UserInfo> userHolder = new ThreadLocal<>();
public static void setUser(UserInfo user) {
userHolder.set(user);
}
public static UserInfo getUser() {
return userHolder.get();
}
}
// 场景 4：避免参数传递
public class TransactionContext {
private static ThreadLocal<Transaction> transactionHolder = new ThreadLocal<>();
public static void beginTransaction() {
transactionHolder.set(new Transaction());
}
public static Transaction getTransaction() {
return transactionHolder.get();
}
}
private static finalThreadLocal.withInitial() 提供初始值强引用链：Thread → ThreadLocalMap → Entry[] → Entry → value (强引用)
弱引用：Entry → key (弱引用指向 ThreadLocal)
泄漏场景：
1. ThreadLocal 实例被回收 → key=null
2. 但 value 仍然被 Entry 强引用
3. 线程池中线程长期存活 → value 无法被回收
4. 导致内存泄漏
// 方案 1：手动 remove（推荐）
try {
threadLocal.set(value);
// ... 业务逻辑
} finally {
threadLocal.remove(); // 必须执行！
}
// 方案 2：使用 InheritableThreadLocal（父子线程传递）
ThreadLocal<String> parent = new InheritableThreadLocal<>();
parent.set("parent value");
new Thread(() -> {
// 子线程可以获取父线程的值
System.out.println(parent.get()); // "parent value"
}).start();
// 方案 3：使用 FastThreadLocal（Netty 优化版）
// 适用于高并发场景，避免了哈希冲突
public class SafeThreadLocalExample {
// 1. 使用 static final 修饰
private static final ThreadLocal<SimpleDateFormat> DATE_FORMAT = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
// 2. 包装为工具类
public static Date parse(String dateStr) throws ParseException {
SimpleDateFormat sdf = DATE_FORMAT.get();
try {
return sdf.parse(dateStr);
} finally {
// 注意：这里通常不需要 remove，因为要重用 SimpleDateFormat
// 但如果是用完即弃的场景，应该 remove
}
}
// 3. 线程池场景必须清理
public void executeInThreadPool() {
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
executor.submit(() -> {
try {
UserContext.setUser(new UserInfo());
// ... 业务处理
} finally {
UserContext.remove(); // 关键！
}
});
}
}
}
| 方案 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| ThreadLocal | 线程隔离数据 | 简单高效 | 内存泄漏风险 |
| InheritableThreadLocal | 父子线程传递 | 继承上下文 | 线程池中失效 |
| TransmittableThreadLocal | 线程池传递 | 线程池友好 | 引入依赖 |
| 参数传递 | 简单场景 | 无副作用 | 代码冗余 |
// 查看 ThreadLocalMap 内容（调试用）
public static void dumpThreadLocalMap(Thread thread) throws Exception {
Field field = Thread.class.getDeclaredField("threadLocals");
field.setAccessible(true);
Object map = field.get(thread);
if (map != null) {
Field tableField = map.getClass().getDeclaredField("table");
tableField.setAccessible(true);
Object[] table = (Object[]) tableField.get(map);
for (Object entry : table) {
if (entry != null) {
Field valueField = entry.getClass().getDeclaredField("value");
valueField.setAccessible(true);
System.out.println("Key: " + ((WeakReference<?>) entry).get() + ", Value: " + valueField.get(entry));
}
}
}
}
ThreadLocal 是强大的线程隔离工具，但需要谨慎使用。在 Web 应用和线程池场景中，必须在 finally 块中调用 remove()，这是避免内存泄漏的关键。
关于 ThreadLocal，我从原理、场景和内存泄漏三个方面来说一下我的理解。
简单来说，ThreadLocal 是一个线程级别的变量隔离工具。它的设计目标就是让同一个变量，在不同的线程里有自己独立的副本，互不干扰。
Thread 对象）内部都有一个自己的 ThreadLocalMap（你可以把它想象成一个线程私有的、简易版的 HashMap）。ThreadLocal.set(value) 时，实际上是以当前的 ThreadLocal 实例自身作为 Key，要保存的值作为 Value，存入当前线程的那个 ThreadLocalMap 里。ThreadLocal.get() 时，也是用自己作为 Key，去当前线程的 Map 里查找对应的 Value。Thread 是银行，ThreadLocalMap 是银行里的一排保险箱，ThreadLocal 实例就是你手里那把特定的钥匙。你用这把钥匙（ThreadLocal 实例）只能打开属于你的那个格子（当前线程的 Map），存取自己的东西（Value），完全看不到别人格子的东西。不同的人（线程）即使用同一款钥匙（同一个 ThreadLocal 实例），打开的也是不同银行的格子，东西自然隔离了。正是因为这种线程隔离的特性，它特别适合用来传递一些需要在线程整个生命周期内、多个方法间共享，但又不能（或不想）通过方法参数显式传递的数据。最常见的有两个场景：
get() 到这些信息，避免了在每一个方法签名上都加上这些参数，代码会简洁很多。SimpleDateFormat 这个类，它不是线程安全的。如果做成全局共享，就要加锁，性能差。用 ThreadLocal 的话，每个线程都拥有自己的一个 SimpleDateFormat 实例，既避免了线程安全问题，又因为线程复用了这个实例，减少了创建对象的开销。ThreadLocal 如果使用不当，确实可能导致内存泄漏。它的根源在于 ThreadLocalMap 中 Entry 的设计。
ThreadLocalMap 的 Key（也就是 ThreadLocal 实例）是一个 弱引用。这意味着，如果外界没有强引用指向这个 ThreadLocal 对象（比如我们把 ThreadLocal 变量设为了 null），下次垃圾回收时，这个 Key 就会被回收掉，于是 Map 里就出现了一个 Key 为 null，但 Value 依然存在的 Entry。remove() 方法。这不仅是清理当前值，更重要的是它会清理掉整个 Entry，这是最有效、最安全的做法。ThreadLocal 本身也做了一些努力，比如在 set()、get()、remove() 的时候，会尝试去清理那些 Key 为 null 的过期 Entry。但这是一种'被动清理'，不能完全依赖。ThreadLocal 变量声明为 static final，这样它的生命周期就和类一样长，不会被轻易回收，减少了产生 null Key 的机会。但这并不能替代 remove()，因为线程池复用时，上一个任务的值可能会污染下一个任务。总结一下：内存泄漏的关键是 '弱 Key + 强 Value + 长生命周期线程' 的组合。所以，把 remove() 放在 finally 块里调用，是一个必须养成的编程习惯。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online