Tomcat Guice/JDBC 内存泄漏

Question

由于 Tomcat 中的孤立线程，我遇到了内存泄漏。特别是，Guice 和 JDBC 驱动程序似乎没有关闭线程。

Aug 8, 2012 4:09:19 PM org.apache.catalina.loader.WebappClassLoader clearReferencesThreads
SEVERE: A web application appears to have started a thread named [com.google.inject.internal.util.$Finalizer] but has failed to stop it. This is very likely to create a memory leak.
Aug 8, 2012 4:09:19 PM org.apache.catalina.loader.WebappClassLoader clearReferencesThreads
SEVERE: A web application appears to have started a thread named [Abandoned connection cleanup thread] but has failed to stop it. This is very likely to create a memory leak.

我知道这与其他问题类似（例如this one），但就我而言，“别担心”的答案是不够的，因为它给我带来了问题。我有 CI 服务器，它会定期更新这个应用程序，并且在 6-10 次重新加载后，CI 服务器会因为 Tomcat 内存不足而挂起。

我需要能够清除这些孤立的线程，这样我才能更可靠地运行我的 CI 服务器。任何帮助将不胜感激！

Answer 1

侵入性最小的解决方法是从 webapp 的类加载器之外的代码强制初始化 MySQL JDBC 驱动程序。

在 tomcat/conf/server.xml 中，修改（在 Server 元素内）：

<Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />

到

<Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener"
          classesToInitialize="com.mysql.jdbc.NonRegisteringDriver" />

• 如果使用 mysql-connector-java-8.0.x，请改用 com.mysql.cj.jdbc.NonRegisteringDriver

这假设您将 MySQL JDBC 驱动程序放在 tomcat 的 lib 目录中，而不是放在 webapp.war 的 WEB-INF/lib 目录中，因为重点是在 之前 加载驱动程序并且独立于您的网络应用程序。

参考资料：

• http://bugs.mysql.com/bug.php?id=68556#c400606

• http://tomcat.apache.org/tomcat-7.0-doc/config/listeners.html#JRE_Memory_Leak_Prevention_Listener_-_org.apache.catalina.core.JreMemoryLeakPreventionListener

• http://markmail.org/message/dmvlkps7lbgpngil

• com.mysql.jdbc.NonRegisteringDriver 源 v5.1

• com.mysql.cj.jdbc.NonRegisteringDriver源码v8.0
• Changes in connector/J v8.0

Answer 2

从 MySQL 连接器 5.1.23 开始生效，提供了一种关闭废弃连接清理线程的方法，AbandonedConnectionCleanupThread.shutdown。

但是，我们不希望我们的代码直接依赖于其他不透明的 JDBC 驱动程序代码，所以我的解决方案是使用反射来查找类和方法，如果找到就调用它。以下完整的代码 sn-p 就是所有需要的，在加载 JDBC 驱动程序的类加载器的上下文中执行：

try {
    Class<?> cls=Class.forName("com.mysql.jdbc.AbandonedConnectionCleanupThread");
    Method   mth=(cls==null ? null : cls.getMethod("shutdown"));
    if(mth!=null) { mth.invoke(null); }
    }
catch (Throwable thr) {
    thr.printStackTrace();
    }

如果 JDBC 驱动程序是 MySQL 连接器的最新版本，则此线程干净地结束，否则什么也不做。

注意它必须在类加载器的上下文中执行，因为线程是静态引用；如果在运行此代码时驱动程序类未卸载或尚未卸载，则线程将不会运行以进行后续 JDBC 交互。

Answer 3

这似乎已在 5.1.41 中修复。您可以将 Connector/J 升级到 5.1.41 或更高版本。 https://dev.mysql.com/doc/relnotes/connector-j/5.1/en/news-5-1-41.html

现在改进了 AbandonedConnectionCleanupThread 的实现，因此现在有四种方式供开发人员处理这种情况：

• 当使用默认 Tomcat 配置并将 Connector/J jar 放入本地库目录时，Connector/J 中新的内置应用程序检测器现在可以在 5 秒内检测到 Web 应用程序的停止，并且杀死 AbandonedConnectionCleanupThread。也避免了关于线程不可停止的任何不必要的警告。如果将 Connector/J jar 放入全局库目录，则线程会一直运行，直到 JVM 被卸载。

• 当使用属性 clearReferencesStopThreads="true" 配置 Tomcat 的上下文时，Tomcat 将在应用程序停止时停止所有派生线程，除非连接器/J 与其他 Web 应用程序共享，在这种情况下连接器/J现在受到 Tomcat 不当停止的保护；关于不可停止线程的警告仍然会在 Tomcat 的错误日志中发出。

• 当在上下文销毁时调用 AbandonedConnectionCleanupThread.checkedShutdown() 的每个 Web 应用程序中实现 ServletContextListener 时，如果驱动程序可能与其他应用程序共享，Connector/J 现在会再次跳过此操作。在这种情况下，不会向 Tomcat 的错误日志发出有关线程不可停止的警告。

• 当调用 AbandonedConnectionCleanupThread.uncheckedShutdown() 时，即使 Connector/J 与其他应用程序共享，AbandonedConnectionCleanupThread 也会关闭。但是，之后可能无法重新启动线程。

如果你查看源代码，他们在线程上调用了 setDeamon(true)，所以它不会阻塞关机。

Thread t = new Thread(r, "Abandoned connection cleanup thread");
t.setDaemon(true);

Answer 4

我也遇到过同样的问题，正如 Jeff 所说，“不要担心它的方法”不是要走的路。

我做了一个 ServletContextListener，它在上下文关闭时停止挂起的线程，然后在 web.xml 文件中注册了这样的 ContextListener。

我已经知道停止线程并不是处理它们的优雅方式，否则服务器会在两次或三次部署后继续崩溃（并不总是可以重新启动应用服务器）。

我创建的类是：

public class ContextFinalizer implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(ContextFinalizer.class);

    @Override
    public void contextInitialized(ServletContextEvent sce) {
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        Driver d = null;
        while(drivers.hasMoreElements()) {
            try {
                d = drivers.nextElement();
                DriverManager.deregisterDriver(d);
                LOGGER.warn(String.format("Driver %s deregistered", d));
            } catch (SQLException ex) {
                LOGGER.warn(String.format("Error deregistering driver %s", d), ex);
            }
        }
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        Thread[] threadArray = threadSet.toArray(new Thread[threadSet.size()]);
        for(Thread t:threadArray) {
            if(t.getName().contains("Abandoned connection cleanup thread")) {
                synchronized(t) {
                    t.stop(); //don't complain, it works
                }
            }
        }
    }

}

创建类后，然后在web.xml文件中注册：

<web-app...
    <listener>
        <listener-class>path.to.ContextFinalizer</listener-class>
    </listener>
</web-app>

Answer 5

见To prevent a memory leak, the JDBC Driver has been forcibly unregistered。 Bill 的回答取消了所有 Driver 实例以及可能属于其他 Web 应用程序的实例的注册。我通过检查 Driver 实例是否属于正确的 ClassLoader 来扩展 Bill 的答案。

这是生成的代码（在单独的方法中，因为我的contextDestroyed 有其他事情要做）：

// See https://stackoverflow.com/questions/25699985/the-web-application-appears-to-have-started-a-thread-named-abandoned-connect
// and
// https://stackoverflow.com/questions/3320400/to-prevent-a-memory-leak-the-jdbc-driver-has-been-forcibly-unregistered/23912257#23912257
private void avoidGarbageCollectionWarning()
{
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    Enumeration<Driver> drivers = DriverManager.getDrivers();
    Driver d = null;
    while (drivers.hasMoreElements()) {
        try {
            d = drivers.nextElement();
            if(d.getClass().getClassLoader() == cl) {
                DriverManager.deregisterDriver(d);
                logger.info(String.format("Driver %s deregistered", d));
            }
            else {
                logger.info(String.format("Driver %s not deregistered because it might be in use elsewhere", d.toString()));
            }
        }
        catch (SQLException ex) {
            logger.warning(String.format("Error deregistering driver %s, exception: %s", d.toString(), ex.toString()));
        }
    }
    try {
         AbandonedConnectionCleanupThread.shutdown();
    }
    catch (InterruptedException e) {
        logger.warning("SEVERE problem cleaning up: " + e.getMessage());
        e.printStackTrace();
    }
}

我想知道电话AbandonedConnectionCleanupThread.shutdown() 是否安全。它会干扰其他 Web 应用程序吗？我希望不是，因为AbandonedConnectionCleanupThread.run() 方法不是静态的，但AbandonedConnectionCleanupThread.shutdown() 方法是。

Answer 6

我刚刚自己处理了这个问题。与其他一些答案相反，我不建议发出 t.stop() 命令。此方法已被弃用，并且有充分的理由。参考Oracle's reasons 这样做。

但是有一个解决方案可以消除此错误，而无需求助于t.stop()...

@Oso 提供的大部分代码都可以使用，只需替换以下部分

Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
Thread[] threadArray = threadSet.toArray(new Thread[threadSet.size()]);
for(Thread t:threadArray) {
    if(t.getName().contains("Abandoned connection cleanup thread")) {
        synchronized(t) {
            t.stop(); //don't complain, it works
        }
    }
}

使用MySQL驱动提供的如下方法替换：

try {
    AbandonedConnectionCleanupThread.shutdown();
} catch (InterruptedException e) {
    logger.warn("SEVERE problem cleaning up: " + e.getMessage());
    e.printStackTrace();
}

这应该会正确关闭线程，并且错误应该消失。

Answer 7

Bill 的解决方案看起来不错，但是我直接在 MySQL 错误报告中找到了另一个解决方案：

[2013 年 6 月 5 日 17:12] 克里斯托弗·舒尔茨 在其他情况发生变化之前，这是一个更好的解决方法。

启用 Tomcat 的 JreMemoryLeakPreventionListener（在 Tomcat 7 上默认启用），并将此属性添加到元素：

classesToInitialize="com.mysql.jdbc.NonRegisteringDriver"

如果“classesToInitialize”已在您的 上设置，只需将 NonRegisteringDriver 添加到以逗号分隔的现有值。

以及答案：

[2013 年 6 月 8 日 21:33] Marko Asplund 我使用 JreMemoryLeakPreventionListener / classesToInitialize 解决方法（Tomcat 7.0.39 + MySQL Connector/J 5.1.25）进行了一些测试。

在应用解决方法之前，线程转储列出了多次重新部署 web 应用后的多个 AbandonedConnectionCleanupThread 实例。应用解决方法后，只有一个 AbandonedConnectionCleanupThread 实例。

不过，我不得不修改我的应用程序，并将 MySQL 驱动程序从 webapp 移动到 Tomcat 库。 否则，类加载器无法在 Tomcat 启动时加载 com.mysql.jdbc.NonRegisteringDriver。

我希望它对所有仍在与这个问题作斗争的人有所帮助......

Answer 8

我提取了上面答案中最好的部分，并将它们组合成一个易于扩展的类。这结合了 Oso 的原始建议与 Bill 的驱动程序改进和 Software Monkey 的反射改进。 （我也喜欢 Stephan L 的简单回答，但有时修改 Tomcat 环境本身并不是一个好的选择，尤其是当您必须处理自动缩放或迁移到另一个 Web 容器时。）

我没有直接引用类名、线程名和停止方法，而是将它们封装在一个私有的内部ThreadInfo类中。使用这些 ThreadInfo 对象的列表，您可以使用相同的代码包含要关闭的其他麻烦线程。这比大多数人可能需要的解决方案要复杂一些，但在您需要时应该更通用。

import java.lang.reflect.Method;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.List;
import java.util.Set;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * Context finalization to close threads (MySQL memory leak prevention).
 * This solution combines the best techniques described in the linked Stack
 * Overflow answer.
 * @see <a href="https://stackoverflow.com/questions/11872316/tomcat-guice-jdbc-memory-leak">Tomcat Guice/JDBC Memory Leak</a>
 */
public class ContextFinalizer
    implements ServletContextListener {

    private static final Logger LOGGER =
        LoggerFactory.getLogger(ContextFinalizer.class);

    /**
     * Information for cleaning up a thread.
     */
    private class ThreadInfo {

        /**
         * Name of the thread's initiating class.
         */
        private final String name;

        /**
         * Cue identifying the thread.
         */
        private final String cue;

        /**
         * Name of the method to stop the thread.
         */
        private final String stop;

        /**
         * Basic constructor.
         * @param n Name of the thread's initiating class.
         * @param c Cue identifying the thread.
         * @param s Name of the method to stop the thread.
         */
        ThreadInfo(final String n, final String c, final String s) {
            this.name = n;
            this.cue  = c;
            this.stop = s;
        }

        /**
         * @return the name
         */
        public String getName() {
            return this.name;
        }

        /**
         * @return the cue
         */
        public String getCue() {
            return this.cue;
        }

        /**
         * @return the stop
         */
        public String getStop() {
            return this.stop;
        }
    }

    /**
     * List of information on threads required to stop.  This list may be
     * expanded as necessary.
     */
    private List<ThreadInfo> threads = Arrays.asList(
        // Special cleanup for MySQL JDBC Connector.
        new ThreadInfo(
            "com.mysql.jdbc.AbandonedConnectionCleanupThread", //$NON-NLS-1$
            "Abandoned connection cleanup thread", //$NON-NLS-1$
            "shutdown" //$NON-NLS-1$
        )
    );

    @Override
    public void contextInitialized(final ServletContextEvent sce) {
        // No-op.
    }

    @Override
    public final void contextDestroyed(final ServletContextEvent sce) {

        // Deregister all drivers.
        Enumeration<Driver> drivers = DriverManager.getDrivers();
        while (drivers.hasMoreElements()) {
            Driver d = drivers.nextElement();
            try {
                DriverManager.deregisterDriver(d);
                LOGGER.info(
                    String.format(
                        "Driver %s deregistered", //$NON-NLS-1$
                        d
                    )
                );
            } catch (SQLException e) {
                LOGGER.warn(
                    String.format(
                        "Failed to deregister driver %s", //$NON-NLS-1$
                        d
                    ),
                    e
                );
            }
        }

        // Handle remaining threads.
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        Thread[] threadArray = threadSet.toArray(new Thread[threadSet.size()]);
        for (Thread t:threadArray) {
            for (ThreadInfo i:this.threads) {
                if (t.getName().contains(i.getCue())) {
                    synchronized (t) {
                        try {
                            Class<?> cls = Class.forName(i.getName());
                            if (cls != null) {
                                Method mth = cls.getMethod(i.getStop());
                                if (mth != null) {
                                    mth.invoke(null);
                                    LOGGER.info(
                                        String.format(
            "Connection cleanup thread %s shutdown successfully.", //$NON-NLS-1$
                                            i.getName()
                                        )
                                    );
                                }
                            }
                        } catch (Throwable thr) {
                            LOGGER.warn(
                                    String.format(
            "Failed to shutdown connection cleanup thread %s: ", //$NON-NLS-1$
                                        i.getName(),
                                        thr.getMessage()
                                    )
                                );
                            thr.printStackTrace();
                        }
                    }
                }
            }
        }
    }

}

Answer 9

我比Oso更进一步，对上面的代码进行了两点改进：

1. 将 Finalizer 线程添加到需要终止检查：

   for(Thread t:threadArray) {
           if(t.getName().contains("Abandoned connection cleanup thread") 
               ||  t.getName().matches("com\\.google.*Finalizer")
               ) {
           synchronized(t) {
               logger.warn("Forcibly stopping thread to avoid memory leak: " + t.getName());
               t.stop(); //don't complain, it works
           }
       }
   }
   

2. 睡一会儿，让线程有时间停止。没有那个，tomcat一直在抱怨。

   try {
       Thread.sleep(1000);
   } catch (InterruptedException e) {
       logger.debug(e.getMessage(), e);
   }