知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# ThreadLocal 原理与内存泄漏 > 导读:本文从"每个线程一份的状态,怎么才能不靠参数满天飞"这个痛点出发,把 ThreadLocal 的数据结构方向、Entry 的弱引用 key、探测式清理、内存泄漏与线程池串号问题一次讲透,最后给出生产用法与避坑。适合想搞懂 ThreadLocal 底层、以及正在准备后端面试的同学。 ## 一、先建立全局认知 ### Q:ThreadLocal 到底解决了什么问题? A:结论先行——它解决的是"**把每个线程独享的状态,从方法参数里解放出来**"。 一个典型的困扰是:一次请求进来,链路里要带上"当前登录用户""本次 traceId"。如果走参数传递,从 Controller 到 Service 到 DAO,每一个方法签名都得加一个参数,改一处牵动全链路。而这类状态的特点是**同一条请求的处理线程是同一个**,把它挂在"线程"身上,任何一层都能随手取到,既不污染方法签名,也不会互相干扰。 ThreadLocal(线程本地变量,即每个线程各自持有一份副本的变量)就是干这个的:你通过同一个 `ThreadLocal` 对象存取,但**每个线程读到的都是自己的那一份**。 几个高频场景: - **用户上下文**:把登录用户、租户 ID 存进去,Service 层随处可读; - **链路追踪**:`traceId` 一次生成、全程透传; - **非线程安全的工具复用**:`SimpleDateFormat` 不是线程安全的,用 ThreadLocal 让每个线程各持一个实例,省去反复 new 的开销; - **事务上下文**:Spring 的事务同步、连接绑定,本质也是线程维度的状态。 ### Q:为什么说它的"方向"和直觉相反? A:这是理解 ThreadLocal 的第一个门槛。初学者的直觉是"**ThreadLocal 里存了一个 Map,key 是线程、value 是数据**"——**这个方向是错的**。 真实结构恰恰相反:**每个 `Thread` 内部持有一个 `ThreadLocalMap`,key 是 `ThreadLocal` 对象,value 才是你存的数据**。也就是说,数据是"挂在线程自己身上"的,`ThreadLocal` 只是那把"钥匙"。想清楚这一点,后面的内存泄漏才好解释。 ## 二、理解核心机制 ### Q:Thread、ThreadLocalMap、Entry 三者的引用关系是怎样的? A:一层层拆开: - 每个 `Thread` 对象里有一个字段 `threadLocals`,类型是 `ThreadLocal.ThreadLocalMap`; - `ThreadLocalMap` 内部有个 `Entry` 数组,`Entry` 继承自 `WeakReference<ThreadLocal<?>>`,**key 是 ThreadLocal(弱引用)**,**value 是你存的对象(强引用)**; - 你调用 `threadLocal.get()` 时,实际是拿当前线程的 `ThreadLocalMap`,再用 `threadLocal` 这个 key 去查。  *图:Thread → ThreadLocalMap → Entry 的引用链,以及 Entry 中 key(弱引用)被回收后 value(强引用)仍被线程持有的泄漏路径。* 由此得到一条完整的强引用链:**Thread → ThreadLocalMap → Entry → value**。注意,这条链上**没有** ThreadLocal,因为 ThreadLocal 只是弱引用的 key。 ### Q:`get` / `set` / `remove` 的流程是什么? A:先看 `set`:拿到当前线程的 `ThreadLocalMap`,如果是空的就先 `createMap` 创建;否则以 `this`(当前 ThreadLocal)为 key 写入。 `get` 则先取当前线程的 map,再用 `this` 去查 Entry: ```java // ThreadLocal.get() 核心逻辑(JDK 8) public T get() { Thread t = Thread.currentThread(); ThreadLocalMap map = getMap(t); if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { return (T) e.value; } } return setInitialValue(); // 没找到就初始化 } ``` `setInitialValue` 就是调用 `initialValue()`(默认返回 `null`,子类可覆写)并把结果 `set` 进 map,最后返回初始值。所以哪怕你从没 `set` 过,第一次 `get` 也不会为 null(除非 `initialValue` 返回 null)。 `remove` 则是把当前线程 map 中 key 为 `this` 的 Entry 清掉。 **关键点**:这三个方法操作的都是"**当前线程**"的 map,所以跨线程取不到别人的数据——这既是它的能力,也是后面 InheritableThreadLocal 要解决的问题。 顺带记一条使用约定:`ThreadLocal` 通常声明为 `private static final`。因为 key 就是 ThreadLocal 对象本身,**每次 new 一个新的 ThreadLocal,在 map 里就是一把全新的钥匙**,同一个线程里会不断堆积互不相干的 Entry——既取不到之前的值,又制造了额外的过期条目。 ### Q:ThreadLocalMap 的哈希冲突怎么解决?为什么不用链表? A:用的是**开放寻址法(线性探测)**,而不是 HashMap 的"数组 + 链表"。 具体做法:用 `threadLocalHashCode` 对数组长度取模,算出初始下标;如果该位置已被占用,就**往后一格一格地找**,直到找到空位(`set`)或找到匹配的 key(`get`)。为了减少聚集,这个哈希值每次递增一个常量 `0x61c88647`(黄金分割数),让 key 在数组里分布得更均匀。 为什么不用链表?因为一个线程里的 ThreadLocal 数量通常很少(几个到十几个),开放寻址实现更简单、内存更省(Entry 不需要 next 指针),而且随机探测在低冲突率下更快。 还有一个细节:`ThreadLocalMap` 判断"是不是同一个 key"用的是 `k == key` 的**引用相等**,而不是 `equals`。这也印证了前面的约定——同一个 ThreadLocal 必须是同一个对象实例,否则在 map 里就是两个不同的 key。 ### Q:`expungeStaleEntry` 和 `cleanSomeSlots` 是什么时候触发的? A:它们是 ThreadLocalMap 的**探测式清理(其实叫"探测过程中顺手清理")**。当 `set` / `get` 发现某个位置的 key 是 `null`(说明它已被 GC 回收,成了"stale entry",即过期条目),就会调用 `expungeStaleEntry`,把它清掉,并顺着数组往后继续探测,把后面所有 key 为 null 的 Entry 的 value 一并置为 null,帮助回收。 `cleanSomeSlots` 则是在 `set` 新值时按**启发式的对数次数**扫一部分槽位做清理;`rehash` 里还有一次不带条件的全量 `expungeStaleEntries`。 要强调的是:**这些都是"被动触发"的清理**——只有当你继续调用 `set` / `get` / `remove` 动了这个 map,才有机会清理。如果线程从此不再碰它的 ThreadLocal,这些过期 Entry 就一直挂着。这正是内存泄漏的伏笔。 ## 三、放进真实场景 ### Q:为什么 key 用弱引用,value 用强引用?泄漏到底怎么发生的? A:这是最常被问、也最容易答错的一环。 **为什么 key 是弱引用?** 如果 key 是强引用,那么 `ThreadLocalMap` 会反过来强引用 `ThreadLocal` 对象。只要线程还活着,这个 `ThreadLocal`(即便外部已经没有任何引用)就永远回收不掉,泄漏的是 `ThreadLocal` 本身。用弱引用,可以在外部不再持有 `ThreadLocal` 时让 key 被回收,这是**尽力避免泄漏**的设计。 **那 value 为什么是强引用?** 因为 value 就是你真正要用的业务数据,必须保证在使用期间不被误回收。 **泄漏是怎么来的?** 一旦 key(弱引用)被 GC 回收变成 `null`,`Entry` 就成了一条"**key 为 null、value 还在**"的记录。此时存在一条强引用链:**Thread → ThreadLocalMap → Entry → value**。只要线程存活,这条链就不断,**value 永远回收不了**。而 key 已经没了,你再用任何 `ThreadLocal` 都定位不到这条 Entry,也就无法读取或覆盖它——它成了"幽灵数据"。 **线程池把后果放大了**:普通线程用完就结束,线程对象被回收,map 随之消失,泄漏量有限。但线程池里的核心线程**是长期存活的**,一次泄漏就会累积在池里永不释放,最终可能 OOM。 **所以要显式 `remove()`**:它会把 Entry 的 value 置为 null 并断开引用,是唯一能主动、彻底切断泄漏链的手段。"等 GC 顺手清理"不行——弱引用只能帮你回收 key,value 只能靠 `expungeStaleEntry` 这类被动清理,而它要求你**之后还得再访问这个 map**才可能触发;线程如果不再访问,就永远轮不到。 ### Q:线程池复用线程,为什么会串号? A:线程池的核心思想是"线程复用"。同一个线程会先后执行不同任务,如果前一个任务 `set` 了 ThreadLocal 却没清理,**它留在该线程 map 里的值,会被下一个任务读到**。这就是脏数据。 下面是一个可复现的最小示例:用固定单线程的池,让两个任务共用同一个 ThreadLocal,中间不清理。 ```java public class ThreadLocalLeakDemo { static final ThreadLocal<String> USER = new ThreadLocal<>(); public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(1); // 只有 1 个线程,必然复用 pool.submit(() -> { USER.set("alice"); // 任务 A 写入,未 remove System.out.println("A 读到: " + USER.get()); // alice }).get(); pool.submit(() -> { // 任务 B 本不该有用户信息,却读到了上一个任务残留的 alice System.out.println("B 读到: " + USER.get()); // alice(脏数据!) }).get(); pool.shutdown(); } } ``` 输出里任务 B 会读到 `alice`——它压根没设置过。**根因就是线程复用 + 未清理**。 修正写法是**用 `try/finally` 保证清理**,把 set 和 remove 成对包住: ```java pool.submit(() -> { try { USER.set("alice"); doBiz(); } finally { USER.remove(); // 无论如何都清理,杜绝串号 } }); ``` 如果想让调用方更省心,可以封装成"带着上下文执行"的工具方法: ```java public static <T> T runWithContext(ThreadLocal<T> tl, T value, Supplier<T> task) { tl.set(value); try { return task.get(); } finally { tl.remove(); // 出口统一清理 } } ``` **关键点**:`remove()` 必须放在 `finally`,否则业务抛异常时清理被跳过,串号照旧。规则一句话——**谁 set,谁负责 remove**。 串号的危害不只是"读到旧值"这么直观:它还可能是**安全类**的——比如 A 用户的请求把身份写进上下文后没清,B 用户的下一个请求在同一线程里读到 A 的身份,就可能越权看到别人的数据。这也是为什么"上下文传递"必须和"上下文清理"成对设计。 ### Q:Spring 框架也用了 ThreadLocal,为什么它通常不背这个锅? A:因为**框架自己会清理**。比如 `RequestContextHolder`(存放当前 `RequestAttributes`)、Spring 的事务同步 `TransactionSynchronizationManager`,它们的生命周期都挂在一次请求 / 一次事务上,框架在请求结束、事务提交或回滚的固定回调里会 `remove`,所以不会跨请求残留。 由此得出一条实用原则:**框架托管的 ThreadLocal 交给框架,你自己 set 的必须自己 remove**。混用时要清楚边界——你往框架的 ThreadLocal 里塞了额外数据,往往要在自己的出口补一次清理。 反过来也要注意:一旦请求被交给**自定义线程池**异步执行(比如 `@Async` 或手动 `submit`),框架的清理回调作用在"原请求线程"上,而任务跑在池里另一个线程上,"框架会清理"这个前提就不再成立,需要自己保证上下文透传与清理。 ### Q:`InheritableThreadLocal` 能解决跨线程吗?为什么在线程池下失效? A:`InheritableThreadLocal`(可继承的线程本地变量)能让**子线程创建时**,把父线程的值复制过去。原理是:`Thread` 构造时会检查父线程有没有 `inheritableThreadLocals`,有就 `childValue` 拷贝一份给子线程。 它在**手动 new Thread** 时有效,但在**线程池**下基本失效,原因是**时机**: ```java static final InheritableThreadLocal<String> CTX = new InheritableThreadLocal<>(); public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(1); // 线程在此时就已创建 CTX.set("parent-value"); // 之后才 set pool.submit(() -> System.out.println("子线程读到: " + CTX.get())); pool.shutdown(); } ``` 子线程是在**创建**线程池那一刻就 new 出来的,那时父线程还没 `set`,所以复制不到;即便复制到了,之后线程被复用,也不会再重新拷贝。**传递只发生在"新建"的瞬间**,而线程池恰恰是"复用而非新建"。 要跨线程池传递,就得用 `TransmittableThreadLocal`(阿里开源的 TTL):它在任务提交和执行的包装层做**捕获与重放**,把提交时刻的上下文带到实际执行的线程上。这里只作为延伸知道即可。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:建议按"结构 → 泄漏 → 场景"三段来答: 1. **先讲结构**:数据方向是 **Thread → ThreadLocalMap → Entry**,不是 ThreadLocal 持有 Map;Entry 的 key 是 `WeakReference<ThreadLocal<?>>`,value 是强引用;冲突用开放寻址 + 线性探测;清理靠 `expungeStaleEntry` / `cleanSomeSlots` 在 `set` / `get` 时被动触发。 2. **再讲泄漏**:key 被回收后,`Thread → ThreadLocalMap → Entry → value` 这条强引用链仍在,value 回收不掉;线程池线程长期存活放大了后果;唯一可靠手段是显式 `remove()`,且要放在 `finally`。 3. **最后讲场景**:线程复用导致串号,用 `try/finally` 清理规避;框架托管的 ThreadLocal 框架会清,自己 set 的自己清;`InheritableThreadLocal` 只在子线程新建时传递,线程池下失效,跨池传递要靠 TTL。 ### Q:如果面试官追问"到底会不会泄漏"? A:要分情况:如果线程用完即止(如 `new Thread` 跑完就结束),map 随线程回收,泄漏影响很小;**真正的风险全在线程长期存活的场景,尤其是线程池**。所以结论不是"ThreadLocal 一定泄漏",而是"**在线程池里不 `remove` 就会泄漏并串号**"。回答到这个层次,既准确又体现了场景意识。 --- ## 自测 1. ThreadLocal 的引用方向是"ThreadLocal 持有 Map"还是"Thread 持有 Map"?Entry 的 key 和 value 各是什么引用类型? 2. key 被 GC 回收后,为什么 value 依然回收不掉?请画出从 Thread 到 value 的引用链。 3. 线程池复用线程时为什么不 `remove` 会串号?为什么 `remove()` 必须放在 `finally` 中? 4. `InheritableThreadLocal` 为什么在线程池里传递不了上下文?它的复制发生在哪个时刻?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入