ThreadLocal 内存泄露的实例分析

前言

之前写了一篇深入分析 ThreadLocal 内存泄漏问题是从理论上分析ThreadLocal的内存泄漏问题,这一篇文章我们来分析一下实际的内存泄漏案例。分析问题的过程比结果更重要,理论结合实际才能彻底分析出内存泄漏的原因。

案例与分析

问题背景

在 Tomcat 中,下面的代码都在 webapp 内,会导致WebappClassLoader泄漏,无法被回收。

public class MyCounter {
        private int count = 0;

        public void increment() {
                count++;
        }

        public int getCount() {
                return count;
        }
}

public class MyThreadLocal extends ThreadLocal<MyCounter> {
}

public class LeakingServlet extends HttpServlet {
        private static MyThreadLocal myThreadLocal = new MyThreadLocal();

        protected void doGet(HttpServletRequest request,
                        HttpServletResponse response) throws ServletException, IOException {

                MyCounter counter = myThreadLocal.get();
                if (counter == null) {
                        counter = new MyCounter();
                        myThreadLocal.set(counter);
                }

                response.getWriter().println(
                                "The current thread served this servlet " + counter.getCount()
                                                + " times");
                counter.increment();
        }
}

上面的代码中,只要LeakingServlet被调用过一次,且执行它的线程没有停止,就会导致WebappClassLoader泄漏。每次你 reload 一下应用,就会多一份WebappClassLoader实例,最后导致 PermGen OutOfMemoryException

解决问题

现在我们来思考一下:为什么上面的ThreadLocal子类会导致内存泄漏?

WebappClassLoader

首先,我们要搞清楚WebappClassLoader是什么鬼?

对于运行在 Java EE容器中的 Web 应用来说,类加载器的实现方式与一般的 Java 应用有所不同。不同的 Web 容器的实现方式也会有所不同。以 Apache Tomcat 来说,每个 Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式,所不同的是它是首先尝试去加载某个类,如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。这是 Java Servlet 规范中的推荐做法,其目的是使得 Web 应用自己的类的优先级高于 Web 容器提供的类。这种代理模式的一个例外是:Java 核心库的类是不在查找范围之内的。这也是为了保证 Java 核心库的类型安全。

也就是说WebappClassLoader是 Tomcat 加载 webapp 的自定义类加载器,每个 webapp 的类加载器都是不一样的,这是为了隔离不同应用加载的类。

那么WebappClassLoader的特性跟内存泄漏有什么关系呢?目前还看不出来,但是它的一个很重要的特点值得我们注意:每个 webapp 都会自己的WebappClassLoader,这跟 Java 核心的类加载器不一样。

我们知道:导致WebappClassLoader泄漏必然是因为它被别的对象强引用了,那么我们可以尝试画出它们的引用关系图。等等!类加载器的作用到底是啥?为什么会被强引用?

类的生命周期与类加载器

要解决上面的问题,我们得去研究一下类的生命周期和类加载器的关系。这个问题说起来又是一篇文章,参考我做的笔记类的生命周期

跟我们这个案例相关的主要是类的卸载:

在类使用完之后,如果满足下面的情况,类就会被卸载:

  1. 该类所有的实例都已经被回收,也就是 Java 堆中不存在该类的任何实例。
  2. 加载该类的ClassLoader已经被回收。
  3. 该类对应的java.lang.Class对象没有任何地方被引用,没有在任何地方通过反射访问该类的方法。

如果以上三个条件全部满足,JVM 就会在方法区垃圾回收的时候对类进行卸载,类的卸载过程其实就是在方法区中清空类信息,Java 类的整个生命周期就结束了。

由Java虚拟机自带的类加载器所加载的类,在虚拟机的生命周期中,始终不会被卸载。Java虚拟机自带的类加载器包括根类加载器、扩展类加载器和系统类加载器。Java虚拟机本身会始终引用这些类加载器,而这些类加载器则会始终引用它们所加载的类的Class对象,因此这些Class对象始终是可触及的。

由用户自定义的类加载器加载的类是可以被卸载的。

注意上面这句话,WebappClassLoader如果泄漏了,意味着它加载的类都无法被卸载,这就解释了为什么上面的代码会导致 PermGen OutOfMemoryException

关键点看下面这幅图

我们可以发现:类加载器对象跟它加载的 Class 对象是双向关联的。这意味着,Class 对象可能就是强引用WebappClassLoader,导致它泄漏的元凶。

引用关系图

理解类加载器与类的生命周期的关系之后,我们可以开始画引用关系图了。(图中的LeakingServlet.classmyThreadLocal引用画的不严谨,主要是想表达myThreadLocal是类变量的意思)
leak_1

下面,我们根据上面的图来分析WebappClassLoader泄漏的原因。

  1. LeakingServlet持有staticMyThreadLocal,导致myThreadLocal的生命周期跟LeakingServlet类的生命周期一样长。意味着myThreadLocal不会被回收,弱引用形同虚设,所以当前线程无法通过ThreadLocalMap的防护措施清除counter的强引用(见深入分析 ThreadLocal 内存泄漏问题)。
  2. 强引用链:thread -> threadLocalMap -> counter -> MyCounter.class -> WebappClassLocader,导致WebappClassLoader泄漏。

总结

内存泄漏是很难发现的问题,往往由于多方面原因造成。ThreadLocal由于它与线程绑定的生命周期成为了内存泄漏的常客,稍有不慎就酿成大祸。

本文只是对一个特定案例的分析,若能以此举一反三,那便是极好的。最后我留另一个类似的案例供读者分析。

本文的案例来自于 Tomcat 的 Wiki MemoryLeakProtection

课后题

假设我们有一个定义在 Tomcat Common Classpath 下的类(例如说在 tomcat/lib 目录下)

public class ThreadScopedHolder {
        private final static ThreadLocal<Object> threadLocal = new ThreadLocal<Object>();

        public static void saveInHolder(Object o) {
                threadLocal.set(o);
        }

        public static Object getFromHolder() {
                return threadLocal.get();
        }
}

两个在 webapp 的类:

public class MyCounter {
        private int count = 0;

        public void increment() {
                count++;
        }

        public int getCount() {
                return count;
        }
}
public class LeakingServlet extends HttpServlet {

        protected void doGet(HttpServletRequest request,
                        HttpServletResponse response) throws ServletException, IOException {

                MyCounter counter = (MyCounter)ThreadScopedHolder.getFromHolder();
                if (counter == null) {
                        counter = new MyCounter();
                        ThreadScopedHolder.saveInHolder(counter);
                }

                response.getWriter().println(
                                "The current thread served this servlet " + counter.getCount()
                                                + " times");
                counter.increment();
        }
}

提示

leak_2

欢迎大家批评指正,留言交流。

参考文章
ClassLoader内存溢出-从tomcat的reload说起
类加载器内存泄露与tomcat自定义加载器
类的生命周期
深入分析 ThreadLocal 内存泄漏问题
Tomcat源码解读系列(四)——Tomcat类加载机制概述
MemoryLeakProtection

转载于:https://my.oschina.net/u/2935389/blog/841687

<think>好的,我现在要详细思考一下ThreadLocal的内存泄漏问题。首先,我需要理解ThreadLocal的基本原理和它在Java中的作用。ThreadLocal是用来提供线程局部变量的,每个线程访问这个变量时都会得到自己的一个独立副本,这样可以避免多线程环境下的竞争问题。例如,在Web开发中,可以用它来保存每个请求的用户信息,保证线程安全。 接下来,我需要了解为什么ThreadLocal会导致内存泄漏。内存泄漏通常是指程序中不再使用的对象无法被垃圾回收,导致内存被无谓占用。ThreadLocal的内存泄漏可能和它的内部实现有关。根据Java的文档,每个Thread对象内部都有一个ThreadLocalMap,这个Map的键是ThreadLocal实例,值则是线程的局部变量。 这里的关键点是ThreadLocalMap的键是弱引用(WeakReference)的。弱引用在垃圾回收时会被自动回收,即使还有弱引用指向对象。这样设计的目的是当ThreadLocal实例不再被其他地方强引用时,Map中的键会被自动清理,防止内存泄漏。但问题可能出在值上,因为值对象是强引用的。如果线程一直存活(比如线程池中的线程),而ThreadLocal实例已经被回收,那么Map中就会出现键为null的Entry,但值仍然存在强引用,导致无法回收,从而引发内存泄漏。 举个例子,假设有一个线程池中的线程长时间运行,使用了ThreadLocal变量。当ThreadLocal实例被置为null后,由于线程的ThreadLocalMap中的键是弱引用,会被回收,但对应的值仍然存在。如果线程持续存活,这部分内存就无法释放,造成泄漏。 解决这个问题的方法通常是在使用完ThreadLocal后,调用它的remove()方法,手动清除Entry。另外,虽然ThreadLocalMap在set、get等方法时会尝试清理过期Entry,但这并不完全可靠,尤其是在高并发或线程复用的情况下。所以,良好的编程习惯是在try-finally块中使用ThreadLocal,确保finally中调用remove()。 另外,Java的弱引用机制在这里起到了部分作用,但并不能完全避免问题,因为值的强引用依然存在。因此,开发者需要主动管理ThreadLocal的生命周期,避免长时间持有不必要的引用。 总结来说,ThreadLocal内存泄漏的主要原因是ThreadLocalMap中键的弱引用和值的强引用结合,加上线程长时间存活导致无法回收。正确使用remove方法和注意线程生命周期是避免泄漏的关键。</think>ThreadLocal 内存泄漏问题是多线程开发中的经典隐患,其根源在于 ThreadLocal 的弱引用机制与线程生命周期的相互作用。以下是逐步分析: 1. **存储结构剖析** - 每个线程内部维护 `ThreadLocalMap`,键为 `ThreadLocal` 实例(弱引用),值为存储对象(强引用) - 代码示例: ```java ThreadLocal<User> userHolder = new ThreadLocal<>(); userHolder.set(currentUser); // 存入当前线程的Map ``` 2. **泄漏触发条件** - 当 `ThreadLocal` 实例失去强引用时(如置为null) - 线程长时间存活(常见于线程池场景) - 未主动调用 `remove()` 方法清理 3. **内存泄漏过程** ``` ┌───────────┐ ┌───────────────────────┐ │ Thread │ │ ThreadLocal (key) │ │ 本地内存 │──弱→ │ (已被GC回收,变为null) │ │ │ ├───────────────────────┤ │ │ 强→ │ 存储对象 (value) │ └───────────┘ └───────────────────────┘ ``` - 键被回收后,值对象因强引用无法释放 - 单个泄漏微小,但高并发下会导致内存持续增长 4. **解决方案** - **强制清理**:使用后立即调用 `remove()` ```java try { userHolder.set(currentUser); // ...业务逻辑 } finally { userHolder.remove(); // 必须执行清理 } ``` - **防御性编码**:将 `ThreadLocal` 声明为 `static final`,避免重复创建 - **监控手段**:通过内存分析工具检测 `ThreadLocalMap` 的 Entry 数量 5. **最佳实践** - 避免在频繁创建销毁的线程中使用(推荐使用线程池时更要注意清理) - 对线程池线程,在任务执行前后增加清理逻辑 - Java 9+ 建议使用 `withInitial` 初始化: ```java private static final ThreadLocal<User> holder = ThreadLocal.withInitial(() -> new User()); ``` 6. **特殊情况处理** - 使用 `InheritableThreadLocal` 时,子线程会复制父线程变量,需双端清理 - FastThreadLocal(Netty优化实现)通过数组存储规避了哈希碰撞问题 通过主动管理和理解存储结构,可有效规避内存泄漏风险。建议在代码审查时特别关注 ThreadLocal 的使用规范。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值