java.lang.Object
- se.jiderhamn.classloader.leak.prevention.ClassLoaderLeakPreventor

All Implemented Interfaces:: EventListener, javax.servlet.ServletContextListener

public class ClassLoaderLeakPreventor
extends Object
implements javax.servlet.ServletContextListener

This class helps prevent classloader leaks.

Basic setup

Activate protection by adding this class as a context listener in your web.xml, like this:

  <listener>
     <listener-class>se.jiderhamn.classloader.leak.prevention.ClassLoaderLeakPreventor</listener-class>
  </listener>

You should usually declare this listener before any other listeners, to make it "outermost".

Configuration

The context listener has a number of settings that can be configured with context parameters in web.xml, i.e.:

   <context-param>
     <param-name>ClassLoaderLeakPreventor.stopThreads</param-name>
     <param-value>false</param-value>
   </context-param>

The available settings are

Parameter name	Default value	Description
`ClassLoaderLeakPreventor.stopThreads`	`true`	Should threads tied to the web app classloader be forced to stop at application shutdown?
`ClassLoaderLeakPreventor.stopTimerThreads`	`true`	Should Timer threads tied to the web app classloader be forced to stop at application shutdown?
`ClassLoaderLeakPreventor.executeShutdownHooks`	`true`	Should shutdown hooks registered from the application be executed at application shutdown?
`ClassLoaderLeakPreventor.threadWaitMs`	`5000` (5 seconds)	No of milliseconds to wait for threads to finish execution, before stopping them.
`ClassLoaderLeakPreventor.shutdownHookWaitMs`	`10000` (10 seconds)	No of milliseconds to wait for shutdown hooks to finish execution, before stopping them. If set to -1 there will be no waiting at all, but Thread is allowed to run until finished.

License

This code is licensed under the Apache 2 license, which allows you to include modified versions of the code in your distributed software, without having to release your source code.

More info

For more info, see here.

Design goals

If you want to help improve this component, you should be aware of the design goals

Primary design goal: Zero dependencies. The component should build and run using nothing but the JDK and the Servlet API. Specifically we should not depend on any logging framework, since they are part of the problem. We also don't want to use any utility libraries, in order not to impose any further dependencies into any project that just wants to get rid of classloader leaks. Access to anything outside of the standard JDK (in order to prevent a known leak) should be managed with reflection.

Secondary design goal: Keep the runtime component in a single .java file. It should be possible to just add this one .java file into your own source tree.

Author:: Mattias Jiderhamn, 2012-2013

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`ClassLoaderLeakPreventor.ClearingThreadLocalProcessor` ThreadLocalProcessor that not only detects and warns about potential leaks, but also tries to clear them
`protected class`	`ClassLoaderLeakPreventor.JURTKiller` Inner class with the sole task of killing JURT finalizer thread after it is done processing jobs.
`protected static interface`	`ClassLoaderLeakPreventor.ThreadLocalProcessor`
`protected class`	`ClassLoaderLeakPreventor.WarningThreadLocalProcessor` ThreadLocalProcessor that detects and warns about potential leaks

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CAUCHO_TRANSACTION_IMPL` Class name for per thread transaction in Caucho Resin transaction manager
`protected boolean`	`executeShutdownHooks` Should shutdown hooks registered from the application be executed at application shutdown?
`protected Field`	`java_lang_Thread_inheritableThreadLocals`
`protected Field`	`java_lang_Thread_threadLocals`
`protected Field`	`java_lang_ThreadLocal$ThreadLocalMap_table`
`protected Field`	`java_lang_ThreadLocal$ThreadLocalMap$Entry_value`
`static String`	`JURT_ASYNCHRONOUS_FINALIZER`
`protected List<javax.servlet.ServletContextListener>`	`otherListeners` Other `ServletContextListener`s to use also
`static int`	`SHUTDOWN_HOOK_WAIT_MS_DEFAULT` Default no of milliseconds to wait for shutdown hook to finish execution
`protected int`	`shutdownHookWaitMs` No of milliseconds to wait for shutdown hooks to finish execution, before stopping them.
`protected boolean`	`startOracleTimeoutThread` Should the `oracle.jdbc.driver.OracleTimeoutPollingThread` thread be forced to start with system classloader, in case Oracle JDBC driver is present?
`protected boolean`	`stopThreads` Should threads tied to the web app classloader be forced to stop at application shutdown?
`protected boolean`	`stopTimerThreads` Should Timer threads tied to the web app classloader be forced to stop at application shutdown?
`static int`	`THREAD_WAIT_MS_DEFAULT` Default no of milliseconds to wait for threads to finish execution
`protected int`	`threadWaitMs` No of milliseconds to wait for threads to finish execution, before stopping them.

Constructor Summary

Constructors
Constructor and Description

ClassLoaderLeakPreventor()

Constructors
Constructor and Description
`ClassLoaderLeakPreventor()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`clearBeanELResolverCache()` Clean the cache of BeanELResolver
`protected void`	`clearDefaultAuthenticator()` Clear the default java.net.Authenticator (in case current one is loaded in web app).
`protected void`	`clearDefaultProxySelector()` If default `ProxySelector` is loaded by web application it needs to be unset
`protected void`	`clearIntrospectionUtilsCache()` Clear IntrospectionUtils caches of Tomcat and Apache Commons Modeler
`protected void`	`clearRmiTargetsMap(Map<?,?> rmiTargetsMap)` Iterate RMI Targets Map and remove entries loaded by web app classloader
`protected void`	`clearThreadLocalsOfAllThreads()`
`protected RuntimeException`	`constructRuntimeExceptionWithoutStackTrace(String message, Throwable cause)` Construct a new `RuntimeException` without any stack trace, in order to avoid any references back to this class
`void`	`contextDestroyed(javax.servlet.ServletContextEvent servletContextEvent)`
`void`	`contextInitialized(javax.servlet.ServletContextEvent servletContextEvent)`
`protected AccessControlContext`	`createAccessControlContext()` Create `AccessControlContext` that is used in `contextInitialized(javax.servlet.ServletContextEvent)`.
`protected void`	`debug(String s)` To "turn off" debug logging override this method in a subclass and make that subclass method empty.
`protected void`	`deregisterIIOServiceProvider()` Unregister ImageIO Service Provider loaded by the web application class loader
`void`	`deregisterJdbcDrivers()` Deregister JDBC drivers loaded by web app classloader
`protected void`	`deregisterPropertyEditors()` Deregister custom property editors
`protected void`	`deregisterRmiTargets()` This method is heavily inspired by org.apache.catalina.loader.WebappClassLoader.clearReferencesRmiTargets()
`protected void`	`deregisterSecurityProviders()` Deregister custom security providers
`protected void`	`deregisterShutdownHooks()` Find and deregister shutdown hooks.
`void`	`destroyThreadGroups()` Destroy any ThreadGroups that are loaded by the application classloader
`protected void`	`error(String s)` To "turn off" error logging override this method in a subclass and make that subclass method empty.
`protected void`	`error(Throwable t)` To "turn off" error logging override this method in a subclass and make that subclass method empty.
`protected Class<?>`	`findClass(String className)`
`protected Class<?>`	`findClass(String className, boolean trySystemCL)`
`protected Field`	`findField(Class<?> clazz, String fieldName)`
`protected Field`	`findFieldOfClass(String className, String fieldName)`
`protected Field`	`findFieldOfClass(String className, String fieldName, boolean trySystemCL)`
`protected Method`	`findMethod(Class<?> clazz, String methodName, Class... parameterTypes)`
`void`	`fixBeanValidationApiLeak()`
`protected void`	`fixGeoToolsLeak()` Shutdown GeoTools cleaner thread as of https://osgeo-org.atlassian.net/browse/GEOT-2742
`protected void`	`fixJsfLeak()` Workaround for leak caused by Mojarra JSF implementation if included in the container.
`protected void`	`forceStartOpenOfficeJurtCleanup()` The bug detailed at https://issues.apache.org/ooo/show_bug.cgi?
`protected void`	`forEachThreadLocalInCurrentThread(ClassLoaderLeakPreventor.ThreadLocalProcessor threadLocalProcessor)` Loop ThreadLocals and inheritable ThreadLocals in current Thread and for each found, invoke the callback interface
`protected void`	`forEachThreadLocalInThread(Thread thread, ClassLoaderLeakPreventor.ThreadLocalProcessor threadLocalProcessor)`
`protected static void`	`gc()` Unlike `System.gc()` this method guarantees that garbage collection has been performed before returning.
`protected Collection<Thread>`	`getAllThreads()` Get a Collection with all Threads.
`protected Authenticator`	`getDefaultAuthenticator()` Find default `Authenticator`
`protected <T> T`	`getFieldValue(Field field, Object obj)`
`protected <T> T`	`getFieldValue(Object obj, String fieldName)`
`protected static int`	`getIntInitParameter(javax.servlet.ServletContext servletContext, String parameterName, int defaultValue)` Parse init parameter for integer value, returning default if not found or invalid
`protected String`	`getLogPrefix()`
`protected <E> E`	`getStaticFieldValue(Class<?> clazz, String fieldName)`
`protected <T> T`	`getStaticFieldValue(Field field)`
`protected <E> E`	`getStaticFieldValue(String className, String fieldName)`
`protected <E> E`	`getStaticFieldValue(String className, String fieldName, boolean trySystemCL)`
`protected ClassLoaderLeakPreventor.ThreadLocalProcessor`	`getThreadLocalProcessor()` Get `ClassLoaderLeakPreventor.ThreadLocalProcessor` to be used.
`protected ClassLoader`	`getWebApplicationClassLoader()`
`protected void`	`info(String s)` To "turn off" info logging override this method in a subclass and make that subclass method empty.
`protected void`	`initAwt()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initDatatypeConverterImpl()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initDocumentBuilderFactory()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initJarUrlConnection()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initJava2dDisposer()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initJavaxSecurityLoginConfiguration()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initJdbcDrivers()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initLdapPoolManager()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initOracleJdbcThread()` See https://github.com/mjiderhamn/classloader-leak-prevention/issues/8 and https://github.com/mjiderhamn/classloader-leak-prevention/issues/23 and http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
`protected void`	`initSecurityPolicy()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initSecurityProviders()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initSunAwtAppContext()` To skip this step override this method in a subclass and make that subclass method empty.
`protected void`	`initSunGC()` To skip this step override this method in a subclass and make that subclass method empty.
`protected boolean`	`isJBoss()` Override this method if you want to customize how we determine if we're running in JBoss WildFly (a.k.a JBoss AS).
`protected boolean`	`isJettyWithJMX()` Are we running in Jetty with JMX enabled?
`protected boolean`	`isJvmShuttingDown()` Is the JVM currently shutting down?
`protected boolean`	`isLoadedByWebApplication(Class<?> clazz)` Test if provided class is loaded with web application classloader
`protected boolean`	`isLoadedInWebApplication(Object o)` Test if provided object is loaded with web application classloader
`protected boolean`	`isOracleJRE()` Override this method if you want to customize how we determine if this is a Oracle/Sun Java Runtime Environment.
`protected boolean`	`isThreadInWebApplication(Thread thread)`
`protected boolean`	`isWebAppClassLoaderOrChild(ClassLoader cl)` Test if provided ClassLoader is the classloader of the web application, or a child thereof
`protected void`	`processThreadLocalMap(Thread thread, ClassLoaderLeakPreventor.ThreadLocalProcessor threadLocalProcessor, Object threadLocalMap)`
`protected void`	`removeShutdownHook(Thread shutdownHook)` Deregister shutdown hook and execute it immediately
`protected void`	`removeWrappedAuthenticators(Authenticator authenticator)` Recursively removed wrapped `Authenticator` loaded in this webapp.
`protected void`	`replaceDOMNormalizerSerializerAbortException()` As reported at https://github.com/mjiderhamn/classloader-leak-prevention/issues/36, invoking `DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument().normalizeDocument();` or `Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); DOMImplementationLS implementation = (DOMImplementationLS)document.getImplementation(); implementation.createLSSerializer().writeToString(document);` may trigger leaks caused by the static fields `com.sun.org.apache.xerces.internal.dom.DOMNormalizer#abort` and `com.sun.org.apache.xml.internal.serialize.DOMSerializerImpl#abort` respectively keeping stacktraces/backtraces that may include references to classes loaded by our web application.
`protected void`	`setFinalStaticField(Field field, Object newValue)`
`protected void`	`stopThreads()` Partially inspired by org.apache.catalina.loader.WebappClassLoader.clearReferencesThreads()
`protected void`	`stopTimerThread(Thread thread)`
`protected void`	`unregisterMBeans()` Unregister MBeans loaded by the web application class loader
`protected void`	`unregisterMXBeanNotificationListeners()` Unregister MBeans loaded by the web application class loader, and MBean `NotificationListener`s loaded by the web application class loader
`protected void`	`unregisterNotificationListeners(NotificationBroadcasterSupport mBean)` Unregister `NotificationListener`s from subclass of `NotificationBroadcasterSupport`, if listener, filter or handback is loaded by the web app classloader.
`protected void`	`unsetCachedKeepAliveTimer()` Since Keep-Alive-Timer thread may have terminated, but still be referenced, we need to make sure it does not reference this classloader.
`protected void`	`waitForThread(Thread thread, long waitMs)` Make the provided Thread stop sleep(), wait() or join() and then give it the provided no of milliseconds to finish executing.
`protected void`	`warn(String s)` To "turn off" warn logging override this method in a subclass and make that subclass method empty.
`protected void`	`warn(Throwable t)` To "turn off" warn logging override this method in a subclass and make that subclass method empty.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - THREAD_WAIT_MS_DEFAULT
```
public static final int THREAD_WAIT_MS_DEFAULT
```
    Default no of milliseconds to wait for threads to finish execution
    
    See Also:
    
    Constant Field Values
  - SHUTDOWN_HOOK_WAIT_MS_DEFAULT
```
public static final int SHUTDOWN_HOOK_WAIT_MS_DEFAULT
```
    Default no of milliseconds to wait for shutdown hook to finish execution
    
    See Also:
    
    Constant Field Values
  - JURT_ASYNCHRONOUS_FINALIZER
```
public static final String JURT_ASYNCHRONOUS_FINALIZER
```
    See Also:
    
    Constant Field Values
  - CAUCHO_TRANSACTION_IMPL
```
public static final String CAUCHO_TRANSACTION_IMPL
```
    Class name for per thread transaction in Caucho Resin transaction manager
    
    See Also:
    
    Constant Field Values
  - stopThreads
```
protected boolean stopThreads
```
    Should threads tied to the web app classloader be forced to stop at application shutdown?
  - stopTimerThreads
```
protected boolean stopTimerThreads
```
    Should Timer threads tied to the web app classloader be forced to stop at application shutdown?
  - executeShutdownHooks
```
protected boolean executeShutdownHooks
```
    Should shutdown hooks registered from the application be executed at application shutdown?
  - startOracleTimeoutThread
```
protected boolean startOracleTimeoutThread
```
    Should the oracle.jdbc.driver.OracleTimeoutPollingThread thread be forced to start with system classloader, in case Oracle JDBC driver is present? This is normally a good idea, but can be disabled in case the Oracle JDBC driver is not used even though it is on the classpath.
  - threadWaitMs
```
protected int threadWaitMs
```
    No of milliseconds to wait for threads to finish execution, before stopping them.
  - shutdownHookWaitMs
```
protected int shutdownHookWaitMs
```
    No of milliseconds to wait for shutdown hooks to finish execution, before stopping them. If set to -1 there will be no waiting at all, but Thread is allowed to run until finished.
  - java_lang_Thread_threadLocals
```
protected final Field java_lang_Thread_threadLocals
```
  - java_lang_Thread_inheritableThreadLocals
```
protected final Field java_lang_Thread_inheritableThreadLocals
```
  - java_lang_ThreadLocal$ThreadLocalMap_table
```
protected final Field java_lang_ThreadLocal$ThreadLocalMap_table
```
  - java_lang_ThreadLocal$ThreadLocalMap$Entry_value
```
protected Field java_lang_ThreadLocal$ThreadLocalMap$Entry_value
```
  - otherListeners
```
protected final List<javax.servlet.ServletContextListener> otherListeners
```
    Other ServletContextListeners to use also
- Constructor Detail
  - ClassLoaderLeakPreventor
```
public ClassLoaderLeakPreventor()
```
- Method Detail
  - contextInitialized
```
public void contextInitialized(javax.servlet.ServletContextEvent servletContextEvent)
```
    Specified by:
    
    contextInitialized in interface javax.servlet.ServletContextListener
  - createAccessControlContext
```
protected AccessControlContext createAccessControlContext()
```
    Create AccessControlContext that is used in contextInitialized(javax.servlet.ServletContextEvent). The motive is to avoid spawned threads from inheriting all the ProtectionDomains of the running code, since that will include the web app classloader.
  - isJBoss
```
protected boolean isJBoss()
```
    Override this method if you want to customize how we determine if we're running in JBoss WildFly (a.k.a JBoss AS).
  - isOracleJRE
```
protected boolean isOracleJRE()
```
    Override this method if you want to customize how we determine if this is a Oracle/Sun Java Runtime Environment.
  - initAwt
```
protected void initAwt()
```
    To skip this step override this method in a subclass and make that subclass method empty. The first call to java.awt.Toolkit.getDefaultToolkit() will spawn a new thread with the same contextClassLoader as the caller. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initSecurityProviders
```
protected void initSecurityProviders()
```
    To skip this step override this method in a subclass and make that subclass method empty. Custom java.security.Provider loaded in your web application and registered with java.security.Security.addProvider() must be unregistered with java.security.Security.removeProvider() at application shutdown, or it will cause leaks. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initJdbcDrivers
```
protected void initJdbcDrivers()
```
    To skip this step override this method in a subclass and make that subclass method empty. Your JDBC driver will be registered in java.sql.DriverManager, which means that if you include your JDBC driver inside your web application, there will be a reference to your webapps classloader from system classes (see part II). The simple solution is to put JDBC driver on server level instead, but you can also deregister the driver at application shutdown. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initSunAwtAppContext
```
protected void initSunAwtAppContext()
```
    To skip this step override this method in a subclass and make that subclass method empty. There will be a strong reference from sun.awt.AppContext#contextClassLoader to the classloader of the calls to sun.awt.AppContext#getAppContext(). Avoid leak by forcing initialization using system classloader. Note that Google Web Toolkit (GWT) will trigger this leak via its use of javax.imageio. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initSecurityPolicy
```
protected void initSecurityPolicy()
```
    To skip this step override this method in a subclass and make that subclass method empty. javax.security.auth.Policy.getPolicy() will keep a strong static reference to the contextClassLoader of the first calling thread. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initDocumentBuilderFactory
```
protected void initDocumentBuilderFactory()
```
    To skip this step override this method in a subclass and make that subclass method empty. The classloader of the first thread to call DocumentBuilderFactory.newInstance().newDocumentBuilder() seems to be unable to garbage collection. Is it believed this is caused by some JVM internal bug. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - replaceDOMNormalizerSerializerAbortException
```
protected void replaceDOMNormalizerSerializerAbortException()
```
    As reported at https://github.com/mjiderhamn/classloader-leak-prevention/issues/36, invoking DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument().normalizeDocument(); or Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); DOMImplementationLS implementation = (DOMImplementationLS)document.getImplementation(); implementation.createLSSerializer().writeToString(document); may trigger leaks caused by the static fields com.sun.org.apache.xerces.internal.dom.DOMNormalizer#abort and com.sun.org.apache.xml.internal.serialize.DOMSerializerImpl#abort respectively keeping stacktraces/backtraces that may include references to classes loaded by our web application. Since the Throwable.backtrace itself cannot be accessed via reflection (see http://bugs.java.com/view_bug.do?bug_id=4496456) we need to replace the with new one without any stack trace.
  - constructRuntimeExceptionWithoutStackTrace
```
protected RuntimeException constructRuntimeExceptionWithoutStackTrace(String message,
                                                                      Throwable cause)
```
    Construct a new RuntimeException without any stack trace, in order to avoid any references back to this class
  - initDatatypeConverterImpl
```
protected void initDatatypeConverterImpl()
```
    To skip this step override this method in a subclass and make that subclass method empty. javax.xml.bind.DatatypeConverterImpl in the JAXB Reference Implementation shipped with JDK 1.6+ will keep a static reference (datatypeFactory) to a concrete subclass of javax.xml.datatype.DatatypeFactory, that is resolved when the class is loaded (which I believe happens if you have custom bindings that reference the static methods in javax.xml.bind.DatatypeConverter). It seems that if for example you have a version of Xerces inside your application, the factory method may resolve org.apache.xerces.jaxp.datatype.DatatypeFactoryImpl as the implementation to use (rather than com.sun.org.apache.xerces.internal.jaxp.datatype.DatatypeFactoryImpl shipped with the JDK), which means there will a reference from javax.xml.bind.DatatypeConverterImpl to your classloader. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initJavaxSecurityLoginConfiguration
```
protected void initJavaxSecurityLoginConfiguration()
```
    To skip this step override this method in a subclass and make that subclass method empty. The class javax.security.auth.login.Configuration will keep a strong static reference to the contextClassLoader of Thread from which the class is loaded. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initJarUrlConnection
```
protected void initJarUrlConnection()
```
    To skip this step override this method in a subclass and make that subclass method empty. The caching mechanism of JarURLConnection can prevent JAR files to be reloaded. See this bug report. It is not entirely clear whether this will actually leak classloaders. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initLdapPoolManager
```
protected void initLdapPoolManager()
```
    To skip this step override this method in a subclass and make that subclass method empty. The contextClassLoader of the thread loading the com.sun.jndi.ldap.LdapPoolManager class may be kept from being garbage collected, since it will start a new thread if the system property. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initJava2dDisposer
```
protected void initJava2dDisposer()
```
    To skip this step override this method in a subclass and make that subclass method empty. Loading the class sun.java2d.Disposer will spawn a new thread with the same contextClassLoader. More info. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initSunGC
```
protected void initSunGC()
```
    To skip this step override this method in a subclass and make that subclass method empty. sun.misc.GC.requestLatency(long), which is known to be called from javax.management.remote.rmi.RMIConnectorServer.start(), will cause the current contextClassLoader to be unavailable for garbage collection. See http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - initOracleJdbcThread
```
protected void initOracleJdbcThread()
```
    See https://github.com/mjiderhamn/classloader-leak-prevention/issues/8 and https://github.com/mjiderhamn/classloader-leak-prevention/issues/23 and http://java.jiderhamn.se/2012/02/26/classloader-leaks-v-common-mistakes-and-known-offenders/
  - contextDestroyed
```
public void contextDestroyed(javax.servlet.ServletContextEvent servletContextEvent)
```
    Specified by:
    
    contextDestroyed in interface javax.servlet.ServletContextListener
  - deregisterIIOServiceProvider
```
protected void deregisterIIOServiceProvider()
```
    Unregister ImageIO Service Provider loaded by the web application class loader
  - deregisterJdbcDrivers
```
public void deregisterJdbcDrivers()
```
    Deregister JDBC drivers loaded by web app classloader
  - unregisterMBeans
```
protected void unregisterMBeans()
```
    Unregister MBeans loaded by the web application class loader
  - unregisterMXBeanNotificationListeners
```
protected void unregisterMXBeanNotificationListeners()
```
    Unregister MBeans loaded by the web application class loader, and MBean NotificationListeners loaded by the web application class loader
  - unregisterNotificationListeners
```
protected void unregisterNotificationListeners(NotificationBroadcasterSupport mBean)
```
    Unregister NotificationListeners from subclass of NotificationBroadcasterSupport, if listener, filter or handback is loaded by the web app classloader.
  - deregisterShutdownHooks
```
protected void deregisterShutdownHooks()
```
    Find and deregister shutdown hooks. Will by default execute the hooks after removing them.
  - removeShutdownHook
```
protected void removeShutdownHook(Thread shutdownHook)
```
    Deregister shutdown hook and execute it immediately
  - deregisterPropertyEditors
```
protected void deregisterPropertyEditors()
```
    Deregister custom property editors
  - deregisterSecurityProviders
```
protected void deregisterSecurityProviders()
```
    Deregister custom security providers
  - clearDefaultAuthenticator
```
protected void clearDefaultAuthenticator()
```
    Clear the default java.net.Authenticator (in case current one is loaded in web app). Includes special workaround for CXF issue https://issues.apache.org/jira/browse/CXF-5442
  - getDefaultAuthenticator
```
protected Authenticator getDefaultAuthenticator()
```
    Find default Authenticator
  - removeWrappedAuthenticators
```
protected void removeWrappedAuthenticators(Authenticator authenticator)
```
    Recursively removed wrapped Authenticator loaded in this webapp. May be needed in case there are multiple CXF applications within the same container.
  - clearDefaultProxySelector
```
protected void clearDefaultProxySelector()
```
    If default ProxySelector is loaded by web application it needs to be unset
  - deregisterRmiTargets
```
protected void deregisterRmiTargets()
```
    This method is heavily inspired by org.apache.catalina.loader.WebappClassLoader.clearReferencesRmiTargets()
  - clearRmiTargetsMap
```
protected void clearRmiTargetsMap(Map<?,?> rmiTargetsMap)
```
    Iterate RMI Targets Map and remove entries loaded by web app classloader
  - clearThreadLocalsOfAllThreads
```
protected void clearThreadLocalsOfAllThreads()
```
  - getThreadLocalProcessor
```
protected ClassLoaderLeakPreventor.ThreadLocalProcessor getThreadLocalProcessor()
```
    Get ClassLoaderLeakPreventor.ThreadLocalProcessor to be used. Override to customize ThreadLocal processing.
  - stopThreads
```
protected void stopThreads()
```
    Partially inspired by org.apache.catalina.loader.WebappClassLoader.clearReferencesThreads()
  - stopTimerThread
```
protected void stopTimerThread(Thread thread)
```
  - waitForThread
```
protected void waitForThread(Thread thread,
                             long waitMs)
```
    Make the provided Thread stop sleep(), wait() or join() and then give it the provided no of milliseconds to finish executing.
    
    Parameters:
    
    thread - The thread to wake up and wait for
    
    waitMs - The no of milliseconds to wait. If <= 0 this method does nothing.
  - destroyThreadGroups
```
public void destroyThreadGroups()
```
    Destroy any ThreadGroups that are loaded by the application classloader
  - unsetCachedKeepAliveTimer
```
protected void unsetCachedKeepAliveTimer()
```
    Since Keep-Alive-Timer thread may have terminated, but still be referenced, we need to make sure it does not reference this classloader.
  - clearBeanELResolverCache
```
protected void clearBeanELResolverCache()
```
    Clean the cache of BeanELResolver
  - fixBeanValidationApiLeak
```
public void fixBeanValidationApiLeak()
```
  - fixJsfLeak
```
protected void fixJsfLeak()
```
    Workaround for leak caused by Mojarra JSF implementation if included in the container. See JAVASERVERFACES-2746
  - fixGeoToolsLeak
```
protected void fixGeoToolsLeak()
```
    Shutdown GeoTools cleaner thread as of https://osgeo-org.atlassian.net/browse/GEOT-2742
  - clearIntrospectionUtilsCache
```
protected void clearIntrospectionUtilsCache()
```
    Clear IntrospectionUtils caches of Tomcat and Apache Commons Modeler
  - forceStartOpenOfficeJurtCleanup
```
protected void forceStartOpenOfficeJurtCleanup()
```
    The bug detailed at https://issues.apache.org/ooo/show_bug.cgi?id=122517 is quite tricky. This is a try to avoid the issues by force starting the threads and it's job queue.
  - getWebApplicationClassLoader
```
protected ClassLoader getWebApplicationClassLoader()
```
  - isLoadedInWebApplication
```
protected boolean isLoadedInWebApplication(Object o)
```
    Test if provided object is loaded with web application classloader
  - isLoadedByWebApplication
```
protected boolean isLoadedByWebApplication(Class<?> clazz)
```
    Test if provided class is loaded with web application classloader
  - isWebAppClassLoaderOrChild
```
protected boolean isWebAppClassLoaderOrChild(ClassLoader cl)
```
    Test if provided ClassLoader is the classloader of the web application, or a child thereof
  - isThreadInWebApplication
```
protected boolean isThreadInWebApplication(Thread thread)
```
  - getStaticFieldValue
```
protected <E> E getStaticFieldValue(Class<?> clazz,
                                    String fieldName)
```
  - getStaticFieldValue
```
protected <E> E getStaticFieldValue(String className,
                                    String fieldName)
```
  - getStaticFieldValue
```
protected <E> E getStaticFieldValue(String className,
                                    String fieldName,
                                    boolean trySystemCL)
```
  - findFieldOfClass
```
protected Field findFieldOfClass(String className,
                                 String fieldName)
```
  - findFieldOfClass
```
protected Field findFieldOfClass(String className,
                                 String fieldName,
                                 boolean trySystemCL)
```
  - findClass
```
protected Class<?> findClass(String className)
```
  - findClass
```
protected Class<?> findClass(String className,
                             boolean trySystemCL)
```
  - findField
```
protected Field findField(Class<?> clazz,
                          String fieldName)
```
  - getStaticFieldValue
```
protected <T> T getStaticFieldValue(Field field)
```
  - getFieldValue
```
protected <T> T getFieldValue(Object obj,
                              String fieldName)
```
  - getFieldValue
```
protected <T> T getFieldValue(Field field,
                              Object obj)
```
  - setFinalStaticField
```
protected void setFinalStaticField(Field field,
                                   Object newValue)
```
  - findMethod
```
protected Method findMethod(Class<?> clazz,
                            String methodName,
                            Class... parameterTypes)
```
  - isJvmShuttingDown
```
protected boolean isJvmShuttingDown()
```
    Is the JVM currently shutting down?
  - getAllThreads
```
protected Collection<Thread> getAllThreads()
```
    Get a Collection with all Threads. This method is heavily inspired by org.apache.catalina.loader.WebappClassLoader.getThreads()
  - forEachThreadLocalInCurrentThread
```
protected void forEachThreadLocalInCurrentThread(ClassLoaderLeakPreventor.ThreadLocalProcessor threadLocalProcessor)
```
    Loop ThreadLocals and inheritable ThreadLocals in current Thread and for each found, invoke the callback interface
  - forEachThreadLocalInThread
```
protected void forEachThreadLocalInThread(Thread thread,
                                          ClassLoaderLeakPreventor.ThreadLocalProcessor threadLocalProcessor)
```
  - processThreadLocalMap
```
protected void processThreadLocalMap(Thread thread,
                                     ClassLoaderLeakPreventor.ThreadLocalProcessor threadLocalProcessor,
                                     Object threadLocalMap)
                              throws IllegalAccessException
```
    Throws:
    
    IllegalAccessException
  - getIntInitParameter
```
protected static int getIntInitParameter(javax.servlet.ServletContext servletContext,
                                         String parameterName,
                                         int defaultValue)
```
    Parse init parameter for integer value, returning default if not found or invalid
  - gc
```
protected static void gc()
```
    Unlike System.gc() this method guarantees that garbage collection has been performed before returning.
  - getLogPrefix
```
protected String getLogPrefix()
```
  - debug
```
protected void debug(String s)
```
    To "turn off" debug logging override this method in a subclass and make that subclass method empty.
  - info
```
protected void info(String s)
```
    To "turn off" info logging override this method in a subclass and make that subclass method empty.
  - warn
```
protected void warn(String s)
```
    To "turn off" warn logging override this method in a subclass and make that subclass method empty. Also turn off warn(Throwable).
  - warn
```
protected void warn(Throwable t)
```
    To "turn off" warn logging override this method in a subclass and make that subclass method empty. Also turn off warn(String).
  - error
```
protected void error(String s)
```
    To "turn off" error logging override this method in a subclass and make that subclass method empty. Also turn off error(Throwable).
  - error
```
protected void error(Throwable t)
```
    To "turn off" error logging override this method in a subclass and make that subclass method empty. Also turn off error(String).
  - isJettyWithJMX
```
protected boolean isJettyWithJMX()
```
    Are we running in Jetty with JMX enabled?

Class ClassLoaderLeakPreventor

Basic setup

Configuration

License

More info

Design goals

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

THREAD_WAIT_MS_DEFAULT

SHUTDOWN_HOOK_WAIT_MS_DEFAULT

JURT_ASYNCHRONOUS_FINALIZER

CAUCHO_TRANSACTION_IMPL

stopThreads

stopTimerThreads

executeShutdownHooks

startOracleTimeoutThread

threadWaitMs

shutdownHookWaitMs

java_lang_Thread_threadLocals

java_lang_Thread_inheritableThreadLocals

java_lang_ThreadLocal$ThreadLocalMap_table

java_lang_ThreadLocal$ThreadLocalMap$Entry_value

otherListeners

Constructor Detail

ClassLoaderLeakPreventor

Method Detail

contextInitialized

createAccessControlContext

isJBoss

isOracleJRE

initAwt

initSecurityProviders

initJdbcDrivers

initSunAwtAppContext

initSecurityPolicy

initDocumentBuilderFactory

replaceDOMNormalizerSerializerAbortException

constructRuntimeExceptionWithoutStackTrace

initDatatypeConverterImpl

initJavaxSecurityLoginConfiguration

initJarUrlConnection

initLdapPoolManager

initJava2dDisposer

initSunGC

initOracleJdbcThread

contextDestroyed

deregisterIIOServiceProvider

deregisterJdbcDrivers

unregisterMBeans

unregisterMXBeanNotificationListeners

unregisterNotificationListeners

deregisterShutdownHooks

removeShutdownHook

deregisterPropertyEditors

deregisterSecurityProviders

clearDefaultAuthenticator

getDefaultAuthenticator

removeWrappedAuthenticators

clearDefaultProxySelector

deregisterRmiTargets

clearRmiTargetsMap

clearThreadLocalsOfAllThreads

getThreadLocalProcessor

stopThreads

stopTimerThread

waitForThread

destroyThreadGroups

unsetCachedKeepAliveTimer

clearBeanELResolverCache

fixBeanValidationApiLeak

fixJsfLeak

fixGeoToolsLeak

clearIntrospectionUtilsCache

forceStartOpenOfficeJurtCleanup

getWebApplicationClassLoader

isLoadedInWebApplication