核心认知:ThreadLocal不是"线程安全的Map",而是"每个线程各自的变量副本"。
架构关系(关键:存储在Thread对象中,不是ThreadLocal中):
Thread对象
┌──────────────────────────────────────────┐
│ ... │
│ ThreadLocal.ThreadLocalMap threadLocals │ ← 每个Thread持有一个Map
│ ... │
└──────────────────────────────────────────┘
ThreadLocalMap结构:
┌──────────────────────────────────────────────────────┐
│ Entry[] table │
│ ┌────────┬────────┬────────┬────────┬────────┐ │
│ │ Entry │ Entry │ Entry │ null │ Entry │ ... │
│ │ key=TL1│ key=TL2│ key=TL3│ │ key=TL5│ │
│ │ val=V1 │ val=V2 │ val=V3 │ │ val=V5 │ │
│ └────────┴────────┴────────┴────────┴────────┘ │
│ │
│ key = ThreadLocal对象(弱引用 WeakReference) │
│ value = 线程本地值(强引用) │
└──────────────────────────────────────────────────────┘
引用链:
Thread ─强→ ThreadLocalMap ─强→ Entry[] table ─强→ Entry ─强→ value
│
Entry extends WeakReference<ThreadLocal>
│
Entry ─弱→ ThreadLocal对象(key)
// ThreadLocal.set()
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t); // 获取当前线程的ThreadLocalMap
if (map != null)
map.set(this, value); // this=ThreadLocal对象作为key
else
createMap(t, value);
}
// ThreadLocal.getMap()
ThreadLocalMap getMap(Thread t) {
return t.threadLocals; // 直接从Thread对象取!
}
// ThreadLocal.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();
}
与HashMap不同,ThreadLocalMap使用开放地址法(线性探测)解决hash冲突
原因:
1. ThreadLocalMap Entry数量通常很少(几个到几十个)
2. 开放地址法在数据量少时cache友好,不需要链表指针开销
3. 避免链表/红黑树的复杂性
hash计算:
private final int threadLocalHashCode = nextHashCode();
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT); // +0x61c88647
}
// 0x61c88647 是斐波那契散列的魔数
// 让hash值在2的幂次方容量中完美分布(最小化冲突)
set()过程:
1. 计算 index = threadLocalHashCode & (len - 1)
2. 如果 table[index] 为空 → 直接放入
3. 如果 table[index].key == 当前ThreadLocal → 替换value
4. 如果 table[index].key != 当前ThreadLocal → 线性探测下一个位置
5. 探测过程中遇到 key==null 的Entry(陈旧Entry)→ 清理
探测过程示意:
table: [_] [A] [_] [B] [C] [_] [_]
↑
插入D,hash(D)计算到index=1,但1已被A占据
→ 线性探测到2(空),放入D
table: [_] [A] [D] [B] [C] [_] [_]
get(D)时:hash(D)→index=1,发现key!=D,继续探测到2,找到D
为什么Entry的key用弱引用:
设计者的意图:
ThreadLocal对象在外部不再被引用时,可以被GC回收。
如果key是强引用,即使外部不再使用ThreadLocal,它也无法被回收。
但弱引用key只解决了"key泄漏"问题,没有解决"value泄漏"问题!
内存泄漏的完整因果链:
┌───────────────────────────────────────────────────────────────┐
│ ThreadLocal 内存泄漏全景 │
├───────────────────────────────────────────────────────────────┤
│ │
│ 场景:ThreadLocal对象TL在外部不再被引用 │
│ │
│ 1. TL对象没有被任何地方强引用 │
│ ↓ │
│ 2. GC回收TL对象(因为Entry的key是弱引用) │
│ ↓ │
│ 3. Entry.key = null(被GC清除了),但 Entry.value 仍然存在 │
│ ↓ │
│ 4. 引用链:Thread → ThreadLocalMap → Entry[] → Entry → value │
│ 这条链中value是强引用,只要线程不死,value就不会被回收 │
│ ↓ │
│ 5. 如果是线程池中的线程(不会销毁),value永远无法回收 = 内存泄漏 │
│ │
│ 核心矛盾: │
│ key设计为弱引用 → key能被回收 ✓ │
│ value是强引用 → value不能被回收 ✗ │
│ 线程池线程不销毁 → 整个ThreadLocalMap一直存在 → value泄漏 ✗ │
│ │
└───────────────────────────────────────────────────────────────┘
ThreadLocalMap的自清理机制(不够可靠):
// 在set/get/remove操作中,会顺带清理key==null的Entry(stale entries)
// expungeStaleEntry() 和 cleanSomeSlots()
// 但问题是:
// 1. 只有调用set/get/remove时才会触发清理
// 2. 如果线程不再访问该ThreadLocal,清理永远不会发生
// 3. 线程池中线程被复用,可能长期不访问该ThreadLocal
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 清除指定位置的Entry
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// Rehash直到遇到null
Entry e;
int i;
while ((e = tab[i = nextIndex(i, len)]) != null) {
ThreadLocal<?> k = e.get();
if (k == null) {
e.value = null; // 清理key为null的Entry
tab[i] = null;
size--;
} else {
int h = k.threadLocalHashCode & (len - 1);
if (h != i) {
tab[i] = null;
while (tab[h] != null) h = nextIndex(h, len);
tab[h] = e; // rehash到正确位置
}
}
}
return i;
}
// ========== 错误用法 ==========
// 在线程池中使用ThreadLocal但不清理
ExecutorService pool = Executors.newFixedThreadPool(10);
ThreadLocal<UserContext> ctx = new ThreadLocal<>();
pool.submit(() -> {
ctx.set(new UserContext("张三"));
// ... 业务逻辑
// 没有remove()!下次该线程被复用时,可能读到上次的"张三"
});
// ========== 正确用法 ==========
pool.submit(() -> {
try {
ctx.set(new UserContext("张三"));
// ... 业务逻辑
} finally {
ctx.remove(); // 必须在finally中清理!
}
});
// ========== 更好的做法:封装工具类 ==========
public class UserContextHolder {
private static final ThreadLocal<UserContext> CTX = new ThreadLocal<>();
public static void set(UserContext ctx) { CTX.set(ctx); }
public static UserContext get() { return CTX.get(); }
public static void remove() { CTX.remove(); }
}
// ========== Spring中的最佳实践 ==========
// 利用RequestContextHolder的思路,在Interceptor中set/remove
public class UserContextInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest req, ...) {
UserContextHolder.set(extractUser(req));
return true;
}
@Override
public void afterCompletion(HttpServletRequest req, ...) {
UserContextHolder.remove(); // 请求结束后清理
}
}
陷阱1:数据串扰
线程A设置 ThreadLocal value="user_A"
线程A完成任务,线程池不销毁线程A
线程A被复用执行新任务
新任务中 get() → 得到 "user_A"(上个任务的数据!)
陷阱2:内存泄漏
线程池有100个核心线程
每个线程的ThreadLocalMap中残留了value
100个value对象永远不会被回收
陷阱3:父子线程传递
主线程设置了ThreadLocal
子线程(线程池中的线程)get() → null
InheritableThreadLocal可以解决,但线程池场景下仍有问题
// 解决的问题:线程池中ThreadLocal值传递
// 场景:
// 主线程设置 UserContext → 提交任务到线程池 → 线程池线程需要拿到UserContext
// 普通ThreadLocal/InheritableThreadLocal在线程池场景下无法正确传递
// TTL解决方案:
// 1. 捕获提交线程的所有TTL值
// 2. 在任务执行前设置到执行线程
// 3. 任务执行后恢复执行线程的原有值
// 使用方式
TransmittableThreadLocal<String> ctx = new TransmittableThreadLocal<>();
ctx.set("user_123");
// 方式1:用TtlRunnable/TtlCallable包装
Runnable task = TtlRunnable.get(() -> {
String user = ctx.get(); // "user_123" ✓
});
pool.submit(task);
// 方式2:用TtlExecutors装饰线程池
ExecutorService ttlPool = TtlExecutors.getTtlExecutorService(pool);
ttlPool.submit(() -> {
String user = ctx.get(); // "user_123" ✓
});
// 方式3:Java Agent(无侵入)
// 启动参数加 -javaagent:transmittable-thread-local-2.x.jar
// 自动对所有线程池任务包装
| 特性 | ThreadLocal | InheritableThreadLocal | TransmittableThreadLocal |
|---|---|---|---|
| 线程隔离 | 是 | 是 | 是 |
| 父子线程传递 | 否 | 是(创建时继承) | 是(提交时捕获+恢复) |
| 线程池传递 | 否 | 否(只继承一次) | 是 |
| 内存泄漏风险 | 有 | 有 | 有(同样需要remove) |
| 适用场景 | 简单线程本地变量 | 父线程→子线程传递 | 线程池场景下的上下文传递 |
Q1: ThreadLocal的key为什么用弱引用而不是强引用?
如果用强引用,即使外部不再使用ThreadLocal对象,ThreadLocalMap中的Entry也会持有强引用,导致ThreadLocal对象永远无法被GC回收,造成更严重的内存泄漏。弱引用允许GC回收不再使用的ThreadLocal对象,然后通过清理机制清除对应的value。
Q2: 为什么ThreadLocalMap用开放地址法而不是链表法?
ThreadLocalMap的Entry数量通常很少(一个线程很少创建上百个ThreadLocal),在数据量少时开放地址法更高效:cache友好(连续内存访问),没有链表指针的开销,实现更简单。
Q3: ThreadLocal和synchronized的区别?
synchronized是"共享同步",多个线程共享同一变量,通过互斥保证安全。ThreadLocal是"线程隔离",每个线程各有自己的变量副本,根本不需要同步。解决的是不同层面的问题。
Q4: 为什么0x61c88647这个魔数能让hash完美分布?
0x61c88647是斐波那契散列中的黄金比例乘子(2^32 / φ),它保证在容量为2的幂次方时,连续hash值能均匀分布在table中,最大限度减少冲突。
Q5: 线程池中ThreadLocal导致过线上问题吗?怎么排查的?
(结合实际经验回答)典型问题:用户身份串扰。线程A处理用户1的请求后未remove,线程A被复用处理用户2的请求,错误地拿到了用户1的身份信息。排查方式:在ThreadLocal.set时打印线程名+value,确认是否串扰。
1. 画出Thread → ThreadLocalMap → Entry的引用关系图,标注强引用和弱引用。
2. 解释ThreadLocalMap的set()方法中遇到key==null的Entry时如何处理(expungeStaleEntry)。
3. 编写代码模拟线程池中ThreadLocal数据串扰:提交两个任务到同一线程池,观察是否读到前一个任务的数据。
4. 为什么InheritableThreadLocal在线程池场景下不可靠?给出具体的失败场景。
5. 编写一个自定义ThreadLocal清理拦截器(如Spring Interceptor或Servlet Filter),确保每次请求后自动清理ThreadLocal。