← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L05 - ThreadLocal原理与内存泄漏

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、ThreadLocal整体架构

核心认知: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核心源码


// 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();
}

三、ThreadLocalMap hash冲突处理 —— 开放地址法(探测法)


与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的姿势


// ========== 错误用法 ==========
// 在线程池中使用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可以解决,但线程池场景下仍有问题

七、TransmittableThreadLocal(阿里开源)


// 解决的问题:线程池中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
// 自动对所有线程池任务包装

八、对比总结表

特性ThreadLocalInheritableThreadLocalTransmittableThreadLocal
线程隔离是是是
父子线程传递否是(创建时继承)是(提交时捕获+恢复)
线程池传递否否(只继承一次)是
内存泄漏风险有有有(同样需要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,确认是否串扰。

面试速记卡(考前30秒速看)

练习题(自测)

1. 画出Thread → ThreadLocalMap → Entry的引用关系图,标注强引用和弱引用。

2. 解释ThreadLocalMap的set()方法中遇到key==null的Entry时如何处理(expungeStaleEntry)。

3. 编写代码模拟线程池中ThreadLocal数据串扰:提交两个任务到同一线程池,观察是否读到前一个任务的数据。

4. 为什么InheritableThreadLocal在线程池场景下不可靠?给出具体的失败场景。

5. 编写一个自定义ThreadLocal清理拦截器(如Spring Interceptor或Servlet Filter),确保每次请求后自动清理ThreadLocal。

学习资料