tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ma...@apache.org
Subject [tomcat] branch main updated: Remove JreLeakPreventionListener options that are not required
Date Wed, 28 Jul 2021 11:29:03 GMT
This is an automated email from the ASF dual-hosted git repository.

markt pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tomcat.git


The following commit(s) were added to refs/heads/main by this push:
     new 424cd32  Remove JreLeakPreventionListener options that are not required
424cd32 is described below

commit 424cd322dc60f9ee63e1175e4cf957353d79b88d
Author: Mark Thomas <markt@apache.org>
AuthorDate: Wed Jul 28 12:28:50 2021 +0100

    Remove JreLeakPreventionListener options that are not required
    
    Most of these were fixed in Java 9
---
 .../core/JreMemoryLeakPreventionListener.java      | 225 +--------------------
 .../apache/catalina/core/LocalStrings.properties   |   3 -
 .../catalina/core/LocalStrings_de.properties       |   2 -
 .../catalina/core/LocalStrings_es.properties       |   3 -
 .../catalina/core/LocalStrings_fr.properties       |   3 -
 .../catalina/core/LocalStrings_ja.properties       |   3 -
 .../catalina/core/LocalStrings_ko.properties       |   3 -
 .../catalina/core/LocalStrings_zh_CN.properties    |   3 -
 webapps/docs/config/listeners.xml                  |  69 -------
 9 files changed, 2 insertions(+), 312 deletions(-)

diff --git a/java/org/apache/catalina/core/JreMemoryLeakPreventionListener.java b/java/org/apache/catalina/core/JreMemoryLeakPreventionListener.java
index b3c56a5..7bed3ad 100644
--- a/java/org/apache/catalina/core/JreMemoryLeakPreventionListener.java
+++ b/java/org/apache/catalina/core/JreMemoryLeakPreventionListener.java
@@ -17,30 +17,19 @@
 package org.apache.catalina.core;
 
 import java.io.IOException;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.net.URLConnection;
 import java.sql.DriverManager;
 import java.util.StringTokenizer;
-import java.util.concurrent.ForkJoinPool;
 
 import javax.imageio.ImageIO;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
 
 import org.apache.catalina.Lifecycle;
 import org.apache.catalina.LifecycleEvent;
 import org.apache.catalina.LifecycleListener;
-import org.apache.catalina.startup.SafeForkJoinWorkerThreadFactory;
 import org.apache.juli.logging.Log;
 import org.apache.juli.logging.LogFactory;
-import org.apache.tomcat.util.ExceptionUtils;
 import org.apache.tomcat.util.compat.JreCompat;
-import org.apache.tomcat.util.compat.JreVendor;
 import org.apache.tomcat.util.res.StringManager;
-import org.w3c.dom.Document;
-import org.w3c.dom.ls.DOMImplementationLS;
 
 /**
  * Provide a workaround for known places where the Java Runtime environment can
@@ -61,8 +50,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
     private static final Log log = LogFactory.getLog(JreMemoryLeakPreventionListener.class);
     private static final StringManager sm = StringManager.getManager(JreMemoryLeakPreventionListener.class);
 
-    private static final String FORK_JOIN_POOL_THREAD_FACTORY_PROPERTY =
-            "java.util.concurrent.ForkJoinPool.common.threadFactory";
     /**
      * Protect against the memory leak caused when the first call to
      * <code>sun.awt.AppContext.getAppContext()</code> is triggered by a web
@@ -76,48 +63,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
     }
 
     /**
-     * Protect against the memory leak caused when the first call to
-     * <code>java.awt.Toolkit.getDefaultToolkit()</code> is triggered
-     * by a web application. Defaults to <code>false</code> because a new
-     * Thread is launched.
-     */
-    private boolean awtThreadProtection = false;
-    public boolean isAWTThreadProtection() { return awtThreadProtection; }
-    public void setAWTThreadProtection(boolean awtThreadProtection) {
-      this.awtThreadProtection = awtThreadProtection;
-    }
-
-    /**
-     * Protect against the memory leak caused when the first call to
-     * <code>sun.misc.GC.requestLatency(long)</code> is triggered by a web
-     * application. This first call will start a GC Daemon thread with the
-     * thread's context class loader configured to be the web application class
-     * loader. Defaults to <code>true</code>.
-     *
-     * @see "http://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8157570"
-     */
-    private boolean gcDaemonProtection = true;
-    public boolean isGcDaemonProtection() { return gcDaemonProtection; }
-    public void setGcDaemonProtection(boolean gcDaemonProtection) {
-        this.gcDaemonProtection = gcDaemonProtection;
-    }
-
-     /**
-     * Protect against the memory leak, when the initialization of the
-     * Java Cryptography Architecture is triggered by initializing
-     * a MessageDigest during web application deployment.
-     * This will occasionally start a Token Poller thread with the thread's
-     * context class loader equal to the web application class loader.
-     * Instead we initialize JCA early.
-     * Defaults to <code>true</code>.
-     */
-    private boolean tokenPollerProtection = true;
-    public boolean isTokenPollerProtection() { return tokenPollerProtection; }
-    public void setTokenPollerProtection(boolean tokenPollerProtection) {
-        this.tokenPollerProtection = tokenPollerProtection;
-    }
-
-    /**
      * Protect against resources being read for JAR files and, as a side-effect,
      * the JAR file becoming locked. Note this disables caching for all
      * {@link URLConnection}s, regardless of type. Defaults to
@@ -130,35 +75,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
     }
 
     /**
-     * XML parsing can pin a web application class loader in memory. There are
-     * multiple root causes for this. Some of these are particularly nasty as
-     * profilers may not identify any GC roots related to the leak. For example,
-     * with YourKit you need to ensure that HPROF format memory snapshots are
-     * used to be able to trace some of the leaks.
-     */
-    private boolean xmlParsingProtection = true;
-    public boolean isXmlParsingProtection() { return xmlParsingProtection; }
-    public void setXmlParsingProtection(boolean xmlParsingProtection) {
-        this.xmlParsingProtection = xmlParsingProtection;
-    }
-
-    /**
-     * <code>com.sun.jndi.ldap.LdapPoolManager</code> class spawns a thread when
-     * it is initialized if the system property
-     * <code>com.sun.jndi.ldap.connect.pool.timeout</code> is greater than 0.
-     * That thread inherits the context class loader of the current thread, so
-     * that there may be a web application class loader leak if the web app
-     * is the first to use <code>LdapPoolManager</code>.
-     *
-     * @see "http://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8156824"
-     */
-    private boolean ldapPoolProtection = true;
-    public boolean isLdapPoolProtection() { return ldapPoolProtection; }
-    public void setLdapPoolProtection(boolean ldapPoolProtection) {
-        this.ldapPoolProtection = ldapPoolProtection;
-    }
-
-    /**
      * The first access to {@link DriverManager} will trigger the loading of
      * all {@link java.sql.Driver}s in the the current class loader. The web
      * application level memory leak protection can take care of this in most
@@ -173,21 +89,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
     }
 
     /**
-     * {@link ForkJoinPool#commonPool()} creates a thread pool that, by default,
-     * creates threads that retain references to the thread context class
-     * loader.
-     *
-     * @see "http://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8172726"
-     */
-    private boolean forkJoinCommonPoolProtection = true;
-    public boolean getForkJoinCommonPoolProtection() {
-        return forkJoinCommonPoolProtection;
-    }
-    public void setForkJoinCommonPoolProtection(boolean forkJoinCommonPoolProtection) {
-        this.forkJoinCommonPoolProtection = forkJoinCommonPoolProtection;
-    }
-
-    /**
      * List of comma-separated fully qualified class names to load and initialize during
      * the startup of this Listener. This allows to pre-load classes that are known to
      * provoke classloader leaks if they are loaded during a request processing.
@@ -201,7 +102,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
     }
 
 
-
     @Override
     public void lifecycleEvent(LifecycleEvent event) {
         // Initialise these classes when Tomcat starts
@@ -224,8 +124,7 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
 
             ClassLoader loader = Thread.currentThread().getContextClassLoader();
 
-            try
-            {
+            try {
                 // Use the system classloader as the victim for all this
                 // ClassLoader pinning we're about to do.
                 Thread.currentThread().setContextClassLoader(
@@ -241,7 +140,7 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
                  * - Batik
                  * - others TBD
                  *
-                 * Note tha a call to sun.awt.AppContext.getAppContext() results
+                 * Note that a call to sun.awt.AppContext.getAppContext() results
                  * in a thread being started named AWT-AppKit that requires a
                  * graphical environment to be available.
                  */
@@ -253,67 +152,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
                     ImageIO.getCacheDirectory();
                 }
 
-                // Trigger the creation of the AWT (AWT-Windows, AWT-XAWT,
-                // etc.) thread.
-                // Note this issue is fixed in Java 8 update 05 onwards.
-                if (awtThreadProtection && !JreCompat.isJre9Available()) {
-                    java.awt.Toolkit.getDefaultToolkit();
-                }
-
-                /*
-                 * Several components end up calling
-                 * sun.misc.GC.requestLatency(long) which creates a daemon
-                 * thread without setting the TCCL.
-                 *
-                 * Those libraries / components known to trigger memory leaks
-                 * due to eventual calls to requestLatency(long) are:
-                 * - javax.management.remote.rmi.RMIConnectorServer.start()
-                 *
-                 * Note: Long.MAX_VALUE is a special case that causes the thread
-                 *       to terminate
-                 *
-                 * Fixed in Java 9 onwards (from early access build 130)
-                 */
-                if (gcDaemonProtection && !JreCompat.isJre9Available()) {
-                    try {
-                        Class<?> clazz = Class.forName("sun.misc.GC");
-                        Method method = clazz.getDeclaredMethod(
-                                "requestLatency",
-                                new Class[] {long.class});
-                        method.invoke(null, Long.valueOf(Long.MAX_VALUE - 1));
-                    } catch (ClassNotFoundException e) {
-                        if (JreVendor.IS_ORACLE_JVM) {
-                            log.error(sm.getString(
-                                    "jreLeakListener.gcDaemonFail"), e);
-                        } else {
-                            log.debug(sm.getString(
-                                    "jreLeakListener.gcDaemonFail"), e);
-                        }
-                    } catch (SecurityException | NoSuchMethodException | IllegalArgumentException
|
-                            IllegalAccessException e) {
-                        log.error(sm.getString("jreLeakListener.gcDaemonFail"),
-                                e);
-                    } catch (InvocationTargetException e) {
-                        ExceptionUtils.handleThrowable(e.getCause());
-                        log.error(sm.getString("jreLeakListener.gcDaemonFail"),
-                                e);
-                    }
-                }
-
-                /*
-                 * Creating a MessageDigest during web application startup
-                 * initializes the Java Cryptography Architecture. Under certain
-                 * conditions this starts a Token poller thread with TCCL equal
-                 * to the web application class loader.
-                 *
-                 * Instead we initialize JCA right now.
-                 *
-                 * Fixed in Java 9 onwards (from early access build 133)
-                 */
-                if (tokenPollerProtection && !JreCompat.isJre9Available()) {
-                    java.security.Security.getProviders();
-                }
-
                 /*
                  * Several components end up opening JarURLConnections without
                  * first disabling caching. This effectively locks the file.
@@ -340,65 +178,6 @@ public class JreMemoryLeakPreventionListener implements LifecycleListener
{
                     }
                 }
 
-                /*
-                 * Fixed in Java 9 onwards (from early access build 133)
-                 */
-                if (xmlParsingProtection && !JreCompat.isJre9Available()) {
-                    // There are two known issues with XML parsing that affect
-                    // Java 8+. The issues both relate to cached Exception
-                    // instances that retain a link to the TCCL via the
-                    // backtrace field. Note that YourKit only shows this field
-                    // when using the HPROF format memory snapshots.
-                    // https://bz.apache.org/bugzilla/show_bug.cgi?id=58486
-                    // https://bugs.openjdk.java.net/browse/JDK-8146961
-                    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-                    try {
-                        DocumentBuilder documentBuilder = factory.newDocumentBuilder();
-                        // Issue 1
-                        // com.sun.org.apache.xml.internal.serialize.DOMSerializerImpl
-                        Document document = documentBuilder.newDocument();
-                        document.createElement("dummy");
-                        DOMImplementationLS implementation =
-                                (DOMImplementationLS)document.getImplementation();
-                        implementation.createLSSerializer().writeToString(document);
-                        // Issue 1
-                        // com.sun.org.apache.xerces.internal.dom.DOMNormalizer
-                        document.normalize();
-                    } catch (ParserConfigurationException e) {
-                        log.error(sm.getString("jreLeakListener.xmlParseFail"),
-                                e);
-                    }
-                }
-
-                /*
-                 * Fixed in Java 9 onwards (from early access build 130)
-                 */
-                if (ldapPoolProtection && !JreCompat.isJre9Available()) {
-                    try {
-                        Class.forName("com.sun.jndi.ldap.LdapPoolManager");
-                    } catch (ClassNotFoundException e) {
-                        if (JreVendor.IS_ORACLE_JVM) {
-                            log.error(sm.getString(
-                                    "jreLeakListener.ldapPoolManagerFail"), e);
-                        } else {
-                            log.debug(sm.getString(
-                                    "jreLeakListener.ldapPoolManagerFail"), e);
-                        }
-                    }
-                }
-
-                /*
-                 * Present in Java 7 onwards
-                 * Fixed in Java 9 (from early access build 156)
-                 */
-                if (forkJoinCommonPoolProtection && !JreCompat.isJre9Available())
{
-                    // Don't override any explicitly set property
-                    if (System.getProperty(FORK_JOIN_POOL_THREAD_FACTORY_PROPERTY) == null)
{
-                        System.setProperty(FORK_JOIN_POOL_THREAD_FACTORY_PROPERTY,
-                                SafeForkJoinWorkerThreadFactory.class.getName());
-                    }
-                }
-
                 if (classesToInitialize != null) {
                     StringTokenizer strTok =
                         new StringTokenizer(classesToInitialize, ", \r\n\t");
diff --git a/java/org/apache/catalina/core/LocalStrings.properties b/java/org/apache/catalina/core/LocalStrings.properties
index 7c05313..f97d42a 100644
--- a/java/org/apache/catalina/core/LocalStrings.properties
+++ b/java/org/apache/catalina/core/LocalStrings.properties
@@ -141,10 +141,7 @@ jniLifecycleListener.load.path=Loaded native library from [{0}]
 jniLifecycleListener.missingPathOrName=One of libraryName or libraryPath must be set
 
 jreLeakListener.classToInitializeFail=Failed to load class [{0}] during Tomcat start to prevent
possible memory leaks.
-jreLeakListener.gcDaemonFail=Failed to trigger creation of the GC Daemon thread during Tomcat
start to prevent possible memory leaks. This is expected on non-Sun JVMs.
 jreLeakListener.jarUrlConnCacheFail=Failed to disable Jar URL connection caching by default
-jreLeakListener.ldapPoolManagerFail=Failed to trigger creation of the com.sun.jndi.ldap.LdapPoolManager
class during Tomcat start to prevent possible memory leaks. This is expected on non-Sun JVMs.
-jreLeakListener.xmlParseFail=Error whilst attempting to prevent memory leaks during XML parsing
 
 naming.addEnvEntry=Adding environment entry [{0}]
 naming.addResourceEnvRef=Adding resource env ref [{0}]
diff --git a/java/org/apache/catalina/core/LocalStrings_de.properties b/java/org/apache/catalina/core/LocalStrings_de.properties
index 3a3ac20..3353b87 100644
--- a/java/org/apache/catalina/core/LocalStrings_de.properties
+++ b/java/org/apache/catalina/core/LocalStrings_de.properties
@@ -31,8 +31,6 @@ defaultInstanceManager.invalidInjection=Ungültige ressource injection Annotatio
 
 filterChain.filter=Während der Filter Bearbeitung trat eine Exception auf
 
-jreLeakListener.ldapPoolManagerFail=Konnte die Erzeugung der Klasse com.sun.jndi.ldap.LdapPoolManager
während des Starts von Tomcat nicht auslösen. Dies sollte zur Vermeidung von Memory-Leaks
dienen. Der Fehlschlag ist ein erwartetes Verhalten bei nicht-Sun JVMs.
-
 naming.addEnvEntry=Füge Umgebungseintrag [{0}] hinzu
 naming.namingContextCreationFailed=Erzeugung des Naming-Contexts ist fehlgeschlagen: [{0}]
 naming.wsdlFailed=Die WSDL Datei [{0}] wurde nicht gefunden.
diff --git a/java/org/apache/catalina/core/LocalStrings_es.properties b/java/org/apache/catalina/core/LocalStrings_es.properties
index 89d247d..62ca876 100644
--- a/java/org/apache/catalina/core/LocalStrings_es.properties
+++ b/java/org/apache/catalina/core/LocalStrings_es.properties
@@ -79,10 +79,7 @@ defaultInstanceManager.restrictedServletsResource=No se ha hallado el fichero
de
 filterChain.filter=La ejecución del Filtro lanzó una excepción
 filterChain.servlet=La ejecución del Servlet lanzó una excepción
 
-jreLeakListener.gcDaemonFail=No pude disparar la creación del hilo Daemon GC durante el
arranque de Tomcat para prevenir posibles fallos de memoria. Esto es lo esperado en JVMs no
Sun.
 jreLeakListener.jarUrlConnCacheFail=No pude desactivar la caché de conexión URL de Jar
por defecto
-jreLeakListener.ldapPoolManagerFail=No pude disparar la creación de la clase com.sun.jndi.ldap.LdapPoolManager
durante el arranque de Tomcat para prevenir posibles fallos de memoria. Esto es lo que se
espera si las JVMs no son Sun.
-jreLeakListener.xmlParseFail=Error mientras intentaba prevenir fallos de memoria durante
el análisis XML
 
 naming.addEnvEntry=Adicionando entrada de ambiente [{0}]\n
 naming.bindFailed=No pude cambiar (bind) objeto: [{0}]
diff --git a/java/org/apache/catalina/core/LocalStrings_fr.properties b/java/org/apache/catalina/core/LocalStrings_fr.properties
index 5778813..b587487 100644
--- a/java/org/apache/catalina/core/LocalStrings_fr.properties
+++ b/java/org/apache/catalina/core/LocalStrings_fr.properties
@@ -141,10 +141,7 @@ jniLifecycleListener.load.path=La librairie native a été chargée à
partir de
 jniLifecycleListener.missingPathOrName=Soit libraryName soit libraryPath doivent être définis
 
 jreLeakListener.classToInitializeFail=Echec du chargement de la classe [{0}] pendant le démarrage
de Tomcat, effectué pour empêcher de possibles fuites de mémoire
-jreLeakListener.gcDaemonFail=Echec de la création du thread GC Daemon durant le démarrage
de Tomcat pour éviter une fuite de mémoire, cela est normal sur toutes les JVMs non Oracle
 jreLeakListener.jarUrlConnCacheFail=Échec de la désactivation du cache par défaut des
URL de connexion de JAR
-jreLeakListener.ldapPoolManagerFail=Echec de la création de la classe com.sun.jndi.ldap.LdapPoolManager
durant le démarrage de Tomcat pour éviter une fuite de mémoire, cela est normal sur toutes
les JVMs non Oracle
-jreLeakListener.xmlParseFail=Erreur en essayant de prévenir une fuite de mémoire lors du
traitement de contenu XML
 
 naming.addEnvEntry=Ajout de l''entrée d''environnement [{0}]
 naming.addResourceEnvRef=Ajout de la référence de ressource d''environnement [{0}]
diff --git a/java/org/apache/catalina/core/LocalStrings_ja.properties b/java/org/apache/catalina/core/LocalStrings_ja.properties
index 1f4b3b6..11e99fe 100644
--- a/java/org/apache/catalina/core/LocalStrings_ja.properties
+++ b/java/org/apache/catalina/core/LocalStrings_ja.properties
@@ -141,10 +141,7 @@ jniLifecycleListener.load.path=[{0}] からネイティブライブラリを読
 jniLifecycleListener.missingPathOrName=libraryName あるいは libraryPath を設定しなければなりません。
 
 jreLeakListener.classToInitializeFail=Tomcat起動中に可能なメモリーリークを防止するためのクラス[{0}]をロードすることに失敗しました。
-jreLeakListener.gcDaemonFail=Tomcat の開始時に潜在的なメモリーリークを防ぐ
GC デーモンスレッドの作成を開始できませんでした。Sun の JVM ではない可能性があります。
 jreLeakListener.jarUrlConnCacheFail=既定でJar URL接続のキャッシュを無効にできませんでした。
-jreLeakListener.ldapPoolManagerFail=Tomcatの起動時にメモリリークを防ぐ為にcom.sun.jndi.ldap.LdapPoolManagerクラスの作成をトリガーすることができませんでした。
これはSun以外のJVMであることが予想されます。
-jreLeakListener.xmlParseFail=XML解析中のメモリリークを防止を試行する際のエラー
 
 naming.addEnvEntry=環境変数 [{0}] を追加します。
 naming.addResourceEnvRef=リソースenv ref [{0}]を追加しています。
diff --git a/java/org/apache/catalina/core/LocalStrings_ko.properties b/java/org/apache/catalina/core/LocalStrings_ko.properties
index 30d4a92..0f25107 100644
--- a/java/org/apache/catalina/core/LocalStrings_ko.properties
+++ b/java/org/apache/catalina/core/LocalStrings_ko.properties
@@ -141,10 +141,7 @@ jniLifecycleListener.load.path=[{0}](으)로부터 native 라이브러리를
로
 jniLifecycleListener.missingPathOrName=libraryName 또는 libraryPath, 둘 중 하나는
반드시 설정되어야 합니다.
 
 jreLeakListener.classToInitializeFail=Tomcat을 시작하던 중, 발생 가능성 있는
메모리 누수를 방지하기 위한 클래스 [{0}]을(를) 로드하지 못했습니다.
-jreLeakListener.gcDaemonFail=Tomcat이 시작하는 동안, 가능성 있는 메모리 누수들을
방지하기 위한 GC Daemon 쓰레드 생성을 개시하지 못했습니다. 이는 Sun
JVM들이 아닌 환경에서 발생할 수 있습니다.
 jreLeakListener.jarUrlConnCacheFail=기본 설정으로서, Jar URL 연결 캐싱을 사용불능
상태로 설정하지 못했습니다.
-jreLeakListener.ldapPoolManagerFail=가능성 있는 메모리 누수들을 방지하기
위하여, Tomcat이 시작하는 동안, com.sun.jndi.ldap.LdapPoolManager 클래스 생성을
개시하지 못했습니다. 이는 Sun JVM들이 아닌 환경에서 발생할 수 있습니다.
-jreLeakListener.xmlParseFail=XML 파싱하는 과정에서, 메모리 누수들을 방지하려
시도하는 중 오류 발생
 
 naming.addEnvEntry=Environment 엔트리 [{0}]을(를) 추가합니다.
 naming.addResourceEnvRef=리소스 env ref [{0}]을(를) 추가합니다.
diff --git a/java/org/apache/catalina/core/LocalStrings_zh_CN.properties b/java/org/apache/catalina/core/LocalStrings_zh_CN.properties
index f840c8d..75977b7 100644
--- a/java/org/apache/catalina/core/LocalStrings_zh_CN.properties
+++ b/java/org/apache/catalina/core/LocalStrings_zh_CN.properties
@@ -142,10 +142,7 @@ jniLifecycleListener.load.path=已从[{0}]加载本机库
 jniLifecycleListener.missingPathOrName=必须设置libraryName或libraryPath之一
 
 jreLeakListener.classToInitializeFail=在tomcat启动期间未能加载类[{0}],以防止可能的内存泄漏。
-jreLeakListener.gcDaemonFail=Tomcat开始预防潜在的内存溢出期间,触发GC守护线程失败,在非Sun
JVMs上这是正常的。
 jreLeakListener.jarUrlConnCacheFail=默认情况下无法禁用Jar URL连接缓存。
-jreLeakListener.ldapPoolManagerFail=在Tomcat启动期间未能触发com.sun.jndi.ldap.LdapPoolManager类的创建以防止可能的内存泄漏。这在非Sun
jvm上是预期的。
-jreLeakListener.xmlParseFail=尝试在XML解析期间防止内存泄漏时出错。
 
 naming.addEnvEntry=添加环境条目 [{0}]
 naming.addResourceEnvRef=添加资源环境引用 [{0}]
diff --git a/webapps/docs/config/listeners.xml b/webapps/docs/config/listeners.xml
index 3a512bf..1638dfc 100644
--- a/webapps/docs/config/listeners.xml
+++ b/webapps/docs/config/listeners.xml
@@ -202,15 +202,6 @@
         </p>
       </attribute>
 
-      <attribute name="AWTThreadProtection" required="false">
-        <p>Enables protection so that calls to
-        <code>java.awt.Toolkit.getDefaultToolkit()</code> triggered by a web
-        application do not result in a memory leak.
-        Defaults to <code>false</code> because an AWT thread is launched. This
-        protection is disabled if running on Java 9 onwards since the leak has
-        been fixed for Java 9 onwards.</p>
-      </attribute>
-
       <attribute name="classesToInitialize" required="false">
         <p>List of comma-separated fully qualified class names to load and initialize
         during the startup of this Listener. This allows to pre-load classes that are
@@ -229,57 +220,6 @@
         side-effects. The default is <code>true</code>.</p>
       </attribute>
 
-      <attribute name="forkJoinCommonPoolProtection" required="false">
-        <p>Enables protection so the threads created for
-        <code>ForkJoinPool.commonPool()</code> do not result in a memory leak.
-        The protection is enabled by setting the
-        <code>java.util.concurrent.ForkJoinPool.common.threadFactory</code>
-        system property. If this property is set when Tomcat starts, Tomcat will
-        not over-ride it even if this protection is explicitly enabled. The
-        default is <code>true</code>.  This protection is disabled if running
on
-        Java 9 onwards since the leak has been fixed for Java 9 onwards.</p>
-      </attribute>
-
-      <attribute name="gcDaemonProtection" required="false">
-        <p>Enables protection so that calls to
-        <code>sun.misc.GC.requestLatency(long)</code> triggered by a web
-        application do not result in a memory leak. Use of RMI is likely to
-        trigger a call to this method. A side effect of enabling this protection
-        is the creation of a thread named "GC Daemon". The protection uses
-        reflection to access internal Sun classes and may generate errors on
-        startup on non-Sun JVMs. The default is <code>true</code>. This
-        protection is disabled if running on Java 9 onwards since the leak has
-        been fixed for Java 9 onwards.</p>
-      </attribute>
-
-      <attribute name="ldapPoolProtection" required="false">
-        <p>Enables protection so that the PoolCleaner thread started by
-        <code>com.sun.jndi.ldap.LdapPoolManager</code> does not result in a
-        memory leak. The thread is started the first time the
-        <code>LdapPoolManager</code> class is used if the system property
-        <code>com.sun.jndi.ldap.connect.pool.timeout</code> is set to a value
-        greater than 0. Without this protection, if a web application uses this
-        class the PoolCleaner thread will be configured with the thread's
-        context class loader set to the web application class loader which in
-        turn will trigger a memory leak on reload. Defaults to
-        <code>true</code>. This protection is disabled if running on Java 9
-        onwards since the leak has been fixed for Java 9 onwards.</p>
-      </attribute>
-
-      <attribute name="tokenPollerProtection" required="false">
-        <p>Enables protection so that any token poller thread initialized by
-        <code>sun.security.pkcs11.SunPKCS11.initToken()</code> does not
-        result in a memory leak. The thread is started depending on various
-        conditions as part of the initialization of the Java Cryptography
-        Architecture. Without the protection this can happen during Webapp
-        deployment when the MessageDigest for generating session IDs is
-        initialized. As a result the thread has the Webapp class loader as its
-        thread context class loader. Enabling the protection initializes JCA
-        early during Tomcat startup. Defaults to <code>true</code>. This
-        protection is disabled if running on Java 9 onwards since the leak has
-        been fixed for Java 9 onwards.</p>
-      </attribute>
-
       <attribute name="urlCacheProtection" required="false">
         <p>Enables protection so that reading resources from JAR files using
         <code>java.net.URLConnection</code>s does not result in the JAR file
@@ -289,15 +229,6 @@
         case by case basis as required. Defaults to <code>true</code>.</p>
       </attribute>
 
-      <attribute name="xmlParsingProtection" required="false">
-        <p>Enables protection so that parsing XML files within a web application
-        does not result in a memory leak. Note that memory profilers may not
-        display the GC root associated with this leak making it particularly
-        hard to diagnose. Defaults to <code>true</code>. This protection is
-        disabled if running on Java 9 onwards since the leak has been fixed for
-        Java 9 onwards.</p>
-      </attribute>
-
     </attributes>
 
     <subsection name="JreMemoryLeakPreventionListener Examples">

---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org


Mime
View raw message