Attachment #26157 for bug #49159

View | Details | Raw Unified | Return to bug 49159
Collapse All | Expand All

Lines 30-35 Link Here

(-)conf/server.xml (+2 lines)
30	<!-- JMX Support for the Tomcat server. Documentation at /docs/non-existent.html -->	30	<!-- JMX Support for the Tomcat server. Documentation at /docs/non-existent.html -->
31	<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" />	31	<Listener className="org.apache.catalina.mbeans.ServerLifecycleListener" />
32	<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />	32	<Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
		33	<!-- To use ThreadLocalLeakPreventionListener, the Connectors must be configured with an Executor -->
		34	<!--<Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />-->
33		35
34	<!-- Global JNDI resources	36	<!-- Global JNDI resources
35	Documentation at /docs/jndi-resources-howto.html	37	Documentation at /docs/jndi-resources-howto.html




    private boolean clearReferencesStopTimerThreads = false;
    
    /**
     * Should Tomcat renew the threads of the thread pool when the application
     * is stopped to avoid memory leaks because of uncleaned ThreadLocal
     * variables. This also requires that the threadRenewalDelay property of the
     * StandardThreadExecutor of ThreadPoolExecutor be set to a positive value.
     * objects is not performed in a thread-safe manner.
     */
    private boolean renewThreadsWhenStoppingContext = true;
    
    // ----------------------------------------------------- Context Properties


    }


    public boolean getRenewThreadsWhenStoppingContext() {
        return this.renewThreadsWhenStoppingContext;
     */
    public boolean getClearReferencesThreadLocals() {

        return (this.clearReferencesThreadLocals);

    }

    public void setRenewThreadsWhenStoppingContext(boolean renewThreadsWhenStoppingContext) {
        boolean oldRenewThreadsWhenStoppingContext =
            this.renewThreadsWhenStoppingContext;
        this.renewThreadsWhenStoppingContext = renewThreadsWhenStoppingContext;
        support.firePropertyChange("renewThreadsWhenStoppingContext",
                oldRenewThreadsWhenStoppingContext,
                this.renewThreadsWhenStoppingContext);
            boolean clearReferencesThreadLocals) {

        boolean oldClearReferencesThreadLocals =
            this.clearReferencesThreadLocals;
        this.clearReferencesThreadLocals = clearReferencesThreadLocals;
        support.firePropertyChange("clearReferencesStopThreads",
                                   oldClearReferencesThreadLocals,
                                   this.clearReferencesThreadLocals);

    }



Lines 17-34 Link Here

(-)java/org/apache/catalina/core/StandardThreadExecutor.java (-75 / +30 lines)
17		17
18	package org.apache.catalina.core;	18	package org.apache.catalina.core;
19		19
20	import java.util.Collection;
21	import java.util.concurrent.LinkedBlockingQueue;
22	import java.util.concurrent.ThreadFactory;
23	import java.util.concurrent.ThreadPoolExecutor;
24	import java.util.concurrent.TimeUnit;	20	import java.util.concurrent.TimeUnit;
25	import java.util.concurrent.atomic.AtomicInteger;
26		21
27	import org.apache.catalina.Executor;	22	import org.apache.catalina.Executor;
28	import org.apache.catalina.LifecycleException;	23	import org.apache.catalina.LifecycleException;
29	import org.apache.catalina.LifecycleListener;	24	import org.apache.catalina.LifecycleListener;
30	import org.apache.catalina.util.LifecycleSupport;	25	import org.apache.catalina.util.LifecycleSupport;
31	import java.util.concurrent.RejectedExecutionException;	26	import org.apache.tomcat.util.threads.TaskQueue;
		27	import org.apache.tomcat.util.threads.TaskThreadFactory;
		28	import org.apache.tomcat.util.threads.ThreadPoolExecutor;
32		29
33	public class StandardThreadExecutor implements Executor {	30	public class StandardThreadExecutor implements Executor {
34		31
Lines 49-54 Link Here
49		46
50	protected String name;	47	protected String name;
51		48
		49	/**
		50	* After a context is stopped, threads in the pool are renewed. To avoid
		51	* renewing all threads at the same time, this delay is observed between 2
		52	* threads being renewed.
		53	*/
		54	protected long threadRenewalDelay = 1000L;
		55
52	private LifecycleSupport lifecycle = new LifecycleSupport(this);	56	private LifecycleSupport lifecycle = new LifecycleSupport(this);
53	// ---------------------------------------------- Constructors	57	// ---------------------------------------------- Constructors
54	public StandardThreadExecutor() {	58	public StandardThreadExecutor() {
Lines 61-67 Link Here
61	public void start() throws LifecycleException {	65	public void start() throws LifecycleException {
62	lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);	66	lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
63	TaskQueue taskqueue = new TaskQueue();	67	TaskQueue taskqueue = new TaskQueue();
64	TaskThreadFactory tf = new TaskThreadFactory(namePrefix);	68	TaskThreadFactory tf = new TaskThreadFactory(namePrefix, daemon, threadPriority);
65	lifecycle.fireLifecycleEvent(START_EVENT, null);	69	lifecycle.fireLifecycleEvent(START_EVENT, null);
66	executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,taskqueue, tf);	70	executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), maxIdleTime, TimeUnit.MILLISECONDS,taskqueue, tf);
67	taskqueue.setParent( (ThreadPoolExecutor) executor);	71	taskqueue.setParent( (ThreadPoolExecutor) executor);
Lines 77-92 Link Here
77	}	81	}
78		82
79	public void execute(Runnable command) {	83	public void execute(Runnable command) {
80	if ( executor != null ) {	84	if (executor != null) {
81	try {	85	executor.execute(command);
82	executor.execute(command);
83	} catch (RejectedExecutionException rx) {
84	//there could have been contention around the queue
85	if ( !( (TaskQueue) executor.getQueue()).force(command) ) throw new RejectedExecutionException();
86	}
87	} else throw new IllegalStateException("StandardThreadPool not started.");	86	} else throw new IllegalStateException("StandardThreadPool not started.");
88	}	87	}
89		88
		89	public void contextStopping() {
		90	if (executor != null) {
		91	executor.contextStopping();
		92	}
		93	}
		94
90	public int getThreadPriority() {	95	public int getThreadPriority() {
91	return threadPriority;	96	return threadPriority;
92	}	97	}
Lines 152-157 Link Here
152	public void setName(String name) {	157	public void setName(String name) {
153	this.name = name;	158	this.name = name;
154	}	159	}
		160
		161	public long getThreadRenewalDelay() {
		162	return threadRenewalDelay;
		163	}
		164
		165	public void setThreadRenewalDelay(long threadRenewalDelay) {
		166	this.threadRenewalDelay = threadRenewalDelay;
		167	if(executor!=null) {
		168	executor.setThreadRenewalDelay(threadRenewalDelay);
		169	}
		170	}
155		171
156	/**	172	/**
157	* Add a LifecycleEvent listener to this component.	173	* Add a LifecycleEvent listener to this component.
Lines 206-270 Link Here
206	return (executor != null) ? executor.getQueue().size() : -1;	222	return (executor != null) ? executor.getQueue().size() : -1;
207	}	223	}
208		224
209	// ---------------------------------------------- TaskQueue Inner Class
210	class TaskQueue extends LinkedBlockingQueue<Runnable> {
211	ThreadPoolExecutor parent = null;
212
213	public TaskQueue() {
214	super();
215	}
216
217	public TaskQueue(int initialCapacity) {
218	super(initialCapacity);
219	}
220
221	public TaskQueue(Collection<? extends Runnable> c) {
222	super(c);
223	}
224
225	public void setParent(ThreadPoolExecutor tp) {
226	parent = tp;
227	}
228
229	public boolean force(Runnable o) {
230	if ( parent.isShutdown() ) throw new RejectedExecutionException("Executor not running, can't force a command into the queue");
231	return super.offer(o); //forces the item onto the queue, to be used if the task is rejected
232	}
233
234	public boolean offer(Runnable o) {
235	//we can't do any checks
236	if (parent==null) return super.offer(o);
237	//we are maxed out on threads, simply queue the object
238	if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
239	//we have idle threads, just add it to the queue
240	//this is an approximation, so it could use some tuning
241	if (parent.getActiveCount()<(parent.getPoolSize())) return super.offer(o);
242	//if we have less threads than maximum force creation of a new thread
243	if (parent.getPoolSize()<parent.getMaximumPoolSize()) return false;
244	//if we reached here, we need to add it to the queue
245	return super.offer(o);
246	}
247	}
248
249	// ---------------------------------------------- ThreadFactory Inner Class
250	class TaskThreadFactory implements ThreadFactory {
251	final ThreadGroup group;
252	final AtomicInteger threadNumber = new AtomicInteger(1);
253	final String namePrefix;
254
255	TaskThreadFactory(String namePrefix) {
256	SecurityManager s = System.getSecurityManager();
257	group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
258	this.namePrefix = namePrefix;
259	}
260
261	public Thread newThread(Runnable r) {
262	Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement());
263	t.setDaemon(daemon);
264	t.setPriority(getThreadPriority());
265	return t;
266	}
267	}
268
269
270	}	225	}




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.catalina.core;

import java.util.concurrent.Executor;

import org.apache.catalina.Container;
import org.apache.catalina.ContainerEvent;
import org.apache.catalina.ContainerListener;
import org.apache.catalina.Context;
import org.apache.catalina.Engine;
import org.apache.catalina.Host;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.Server;
import org.apache.catalina.Service;
import org.apache.catalina.connector.Connector;
import org.apache.coyote.ProtocolHandler;
import org.apache.coyote.ajp.AjpAprProtocol;
import org.apache.coyote.ajp.AjpProtocol;
import org.apache.coyote.http11.Http11AprProtocol;
import org.apache.coyote.http11.Http11NioProtocol;
import org.apache.coyote.http11.Http11Protocol;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.threads.ThreadPoolExecutor;

/**
 * A {@link LifecycleListener} that triggers the renewal of threads in Executor
 * pools when a {@link Context} is being stopped to avoid thread-local related
 * memory leaks.<br/>
 * Note : active threads will be renewed one by one when they come back to the
 * pool after executing their task, see
 * {@link org.apache.tomcat.util.threads.ThreadPoolExecutor}.afterExecute().<br/>
 * 
 * This listener must be declared in server.xml to be active, and the connectors
 * must use an Executor instead of their internal thread pool.
 * 
 * @author slaurent
 * 
 */
public class ThreadLocalLeakPreventionListener implements LifecycleListener, ContainerListener {
    private static final Log log = LogFactory.getLog(ThreadLocalLeakPreventionListener.class);

    /**
     * Listens for {@link LifecycleEvent} for the start of the {@link Server} to
     * initialize itself and then for after_stop events of each {@link Context}.
     */
    @Override
    public void lifecycleEvent(LifecycleEvent event) {
        try {
            Lifecycle lifecycle = event.getLifecycle();
            if (Lifecycle.AFTER_START_EVENT.equals(event.getType()) && lifecycle instanceof Server) {
                // when the server starts, we register ourself as listener for
                // all context
                // as well as container event listener so that we know when new
                // Context are deployed
                Server server = (Server) lifecycle;
                registerListenersForServer(server);
            }

            if (Lifecycle.AFTER_STOP_EVENT.equals(event.getType()) && lifecycle instanceof Context) {
                stopIdleThreads((Context) lifecycle);
            }
        } catch (Exception e) {
            log.error("Exception processing event " + event, e);
        }
    }

    @Override
    public void containerEvent(ContainerEvent event) {
        try {
            String type = event.getType();
            if (Container.ADD_CHILD_EVENT.equals(type)) {
                processContainerAddChild(event.getContainer(), (Container) event.getData());
            } else if (Container.REMOVE_CHILD_EVENT.equals(type)) {
                processContainerRemoveChild(event.getContainer(), (Container) event.getData());
            }
        } catch (Exception e) {
            log.error("Exception processing event " + event, e);
        }

    }

    private void registerListenersForServer(Server server) {
        for (Service service : server.findServices()) {
            Engine engine = (Engine) service.getContainer();
            engine.addContainerListener(this);
            registerListenersForEngine(engine);
        }

    }

    private void registerListenersForEngine(Engine engine) {
        for (Container hostContainer : engine.findChildren()) {
            Host host = (Host) hostContainer;
            host.addContainerListener(this);
            registerListenersForHost(host);
        }
    }

    private void registerListenersForHost(Host host) {
        for (Container contextContainer : host.findChildren()) {
            Context context = (Context) contextContainer;
            registerContextListener(context);
        }
    }

    private void registerContextListener(Context context) {
        if (context instanceof Lifecycle) {
            ((Lifecycle) context).addLifecycleListener(this);
        }
    }

    protected void processContainerAddChild(Container parent, Container child) {
        if (log.isDebugEnabled())
            log.debug("Process addChild[parent=" + parent + ",child=" + child + "]");

        try {
            if (child instanceof Context) {
                registerContextListener((Context) child);
            } else if (child instanceof Engine) {
                registerListenersForEngine((Engine) child);
            } else if (child instanceof Host) {
                registerListenersForHost((Host) child);
            }
        } catch (Throwable t) {
            log.error("processContainerAddChild: Throwable", t);
        }

    }

    protected void processContainerRemoveChild(Container parent, Container child) {

        if (log.isDebugEnabled())
            log.debug("Process removeChild[parent=" + parent + ",child=" + child + "]");

        try {
            if (child instanceof Context) {
                Context context = (Context) child;
                if (context instanceof Lifecycle) {
                    ((Lifecycle) context).removeLifecycleListener(this);
                }
            } else if (child instanceof Host) {
                Host host = (Host) child;
                host.removeContainerListener(this);
            } else if (child instanceof Engine) {
                Engine engine = (Engine) child;
                engine.removeContainerListener(this);
            }
        } catch (Throwable t) {
            log.error("processContainerRemoveChild: Throwable", t);
        }

    }

    /**
     * Updates each ThreadPoolExecutor with the current time, which is the time
     * when a context is being stopped.
     * 
     * @param context
     *            the context being stopped, used to discover all the Connectors
     *            of its parent Service.
     */
    private void stopIdleThreads(Context context) {
        if (context instanceof StandardContext && !((StandardContext) context).getRenewThreadsWhenStoppingContext()) {
            log.debug("Not renewing threads when the context is stopping, it is configured not to do it.");
            return;
        }

        Engine engine = (Engine) context.getParent().getParent();
        Service service = engine.getService();
        Connector[] connectors = service.findConnectors();
        if (connectors != null) {
            for (Connector connector : connectors) {
                ProtocolHandler handler = connector.getProtocolHandler();
                Executor executor = null;

                // unfortunately there's no getExecutor() method in
                // ProtocolHandler
                // we have to check each known implementation

                if (handler instanceof Http11Protocol) {
                    executor = ((Http11Protocol) handler).getExecutor();
                } else if (handler instanceof AjpProtocol) {
                    executor = ((AjpProtocol) handler).getExecutor();
                } else if (handler instanceof AjpAprProtocol) {
                    executor = ((AjpAprProtocol) handler).getExecutor();
                } else if (handler instanceof Http11AprProtocol) {
                    executor = ((Http11AprProtocol) handler).getExecutor();
                } else if (handler instanceof Http11NioProtocol) {
                    executor = ((Http11NioProtocol) handler).getExecutor();
                }

                if (executor instanceof StandardThreadExecutor) {
                    StandardThreadExecutor stdThreadExecutor = (StandardThreadExecutor) executor;
                    stdThreadExecutor.contextStopping();
                } else if (executor instanceof ThreadPoolExecutor) {
                    ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
                    threadPoolExecutor.contextStopping();
                }

            }
        }
    }
}

Lines 200-205 Link Here

(-)java/org/apache/catalina/core/mbeans-descriptors.xml (+8 lines)
200	description="Associated realm."	200	description="Associated realm."
201	type="org.apache.catalina.Realm" />	201	type="org.apache.catalina.Realm" />
202		202
		203	<attribute name="renewThreadsWhenStoppingContext"
		204	description="Should Tomcat renew the threads of the thread pool when the application is stopped to avoid memory leaks because of uncleaned ThreadLocal variables."
		205	type="boolean"/>
		206
203	<attribute name="reloadable"	207	<attribute name="reloadable"
204	description="The reloadable flag for this web application"	208	description="The reloadable flag for this web application"
205	type="boolean"/>	209	type="boolean"/>
Lines 708-713 Link Here
708	<attribute name="queueSize"	712	<attribute name="queueSize"
709	description="Number of tasks waiting to be processed"	713	description="Number of tasks waiting to be processed"
710	type="int"/>	714	type="int"/>
		715
		716	<attribute name="threadRenewalDelay"
		717	description="After a context is stopped, threads in the pool are renewed. To avoid renewing all threads at the same time, this delay is observed between 2 threads being renewed. Value is in ms, default value is 1000ms. If negative, threads are not renewed."
		718	type="long"/>
711	</mbean>	719	</mbean>
712		720
713	<mbean name="StandardWrapper"	721	<mbean name="StandardWrapper"

Lines 44-54 Link Here

(-)java/org/apache/catalina/loader/LocalStrings.properties (-5 / +3 lines)
44	webappClassLoader.clearReferencesResourceBundlesFail=Failed to clear ResourceBundle references for web application [{0}]	44	webappClassLoader.clearReferencesResourceBundlesFail=Failed to clear ResourceBundle references for web application [{0}]
45	webappClassLoader.clearRmiInfo=Failed to find class sun.rmi.transport.Target to clear context class loader for web application [{0}]. This is expected on non-Sun JVMs.	45	webappClassLoader.clearRmiInfo=Failed to find class sun.rmi.transport.Target to clear context class loader for web application [{0}]. This is expected on non-Sun JVMs.
46	webappClassLoader.clearRmiFail=Failed to clear context class loader referenced from sun.rmi.transport.Target for web application [{0}]	46	webappClassLoader.clearRmiFail=Failed to clear context class loader referenced from sun.rmi.transport.Target for web application [{0}]
47	webappClassLoader.clearThreadLocalDebug=The web application [{0}] created a ThreadLocal with key of type [{1}] (value [{2}]). The ThreadLocal has been correctly set to null and the key will be removed by GC.	47	webappClassLoader.checkThreadLocalsForLeaksDebug=The web application [{0}] created a ThreadLocal with key of type [{1}] (value [{2}]). The ThreadLocal has been correctly set to null and the key will be removed by GC.
48	webappClassLoader.clearThreadLocal=The web application [{0}] created a ThreadLocal with key of type [{1}] (value [{2}]) and a value of type [{3}] (value [{4}]) but failed to remove it when the web application was stopped. This is very likely to create a memory leak.	48	webappClassLoader.checkThreadLocalsForLeaks=The web application [{0}] created a ThreadLocal with key of type [{1}] (value [{2}]) and a value of type [{3}] (value [{4}]) but failed to remove it when the web application was stopped. This is very likely to create a memory leak, but threads are going to be renewed over time so that the leak should be mitigated.
49	webappClassLoader.clearThreadLocalDebugClear=To simplify the process of tracing memory leaks, the key has been forcibly removed.	49	webappClassLoader.checkThreadLocalsForLeaksFail=Failed to check for ThreadLocal references for web application [{0}]
50	webappClassLoader.clearThreadLocalClear=To prevent a memory leak, the ThreadLocal has been forcibly removed.
51	webappClassLoader.clearThreadLocalFail=Failed to clear ThreadLocal references for web application [{0}]
52	webappClassLoader.stopThreadFail=Failed to terminate thread named [{0}] for web application [{1}]	50	webappClassLoader.stopThreadFail=Failed to terminate thread named [{0}] for web application [{1}]
53	webappClassLoader.stopTimerThreadFail=Failed to terminate TimerThread named [{0}] for web application [{1}]	51	webappClassLoader.stopTimerThreadFail=Failed to terminate TimerThread named [{0}] for web application [{1}]
54	webappClassLoader.validationErrorJarPath=Unable to validate JAR entry with name {0}	52	webappClassLoader.validationErrorJarPath=Unable to validate JAR entry with name {0}




    private boolean clearReferencesStopTimerThreads = false;

    /**
     * Should Tomcat attempt to clear any ThreadLocal objects that are instances
     * of classes loaded by this class loader. Failure to remove any such
     * objects will result in a memory leak on web application stop, undeploy or
     * reload. It is disabled by default since the clearing of the ThreadLocal
     * objects is not performed in a thread-safe manner.
     */
    private boolean clearReferencesThreadLocals = false;
    
    /**
     * Should Tomcat call {@link org.apache.juli.logging.LogFactory#release()}
     * when the class loader is stopped? If not specified, the default value
     * of <code>true</code> is used. Changing the default setting is likely to

     }


     /**
      * Return the clearReferencesThreadLocals flag for this Context.
      */
     public boolean getClearReferencesThreadLocals() {
         return (this.clearReferencesThreadLocals);
     }


     /**
      * Set the clearReferencesThreadLocals feature for this Context.
      *
      * @param clearReferencesThreadLocals The new flag value
      */
     public void setClearReferencesThreadLocals(
             boolean clearReferencesThreadLocals) {
         this.clearReferencesThreadLocals = clearReferencesThreadLocals;
     }


    // ------------------------------------------------------- Reloader Methods



        // Stop any threads the web application started
        clearReferencesThreads();
        
        // Check for leaks triggered by ThreadLocals loaded by this class loader
        checkThreadLocalsForLeaks();
        
        // Clear RMI Targets loaded by this class loader
        clearReferencesRmiTargets();

                Object value = field.get(instance);
                if (null != value) {
                    Class<? extends Object> valueClass = value.getClass();
                    if (!objectIsLoadedByThisOrChildClassLoader(valueClass)) {
                        if (log.isDebugEnabled()) {
                            log.debug("Not setting field " + field.getName() +
                                    " to null in object of class " + 

        }
    }

    private void checkThreadLocalsForLeaks() {
        Thread[] threads = getThreads();

        try {

                if (threads[i] != null) {
                    // Clear the first map
                    threadLocalMap = threadLocalsField.get(threads[i]);
                    checkThreadLocalMapForLeaks(threadLocalMap, tableField);
                    // Clear the second map
                    threadLocalMap =
                        inheritableThreadLocalsField.get(threads[i]);
                    checkThreadLocalMapForLeaks(threadLocalMap, tableField);
                }
            }
        } catch (SecurityException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        } catch (NoSuchFieldException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        } catch (ClassNotFoundException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        } catch (IllegalArgumentException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        } catch (IllegalAccessException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        } catch (NoSuchMethodException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        } catch (InvocationTargetException e) {
            log.warn(sm.getString("webappClassLoader.checkThreadLocalsForLeaksFail",
                    contextName), e);
        }       
    }


    /*
     * Analyzes the given thread local map object. Also pass in the field that
     * points to the internal table to save re-calculating it on every
     * call to this method.
     */
    private void checkThreadLocalMapForLeaks(Object map, Field internalTableField)
            throws NoSuchMethodException, IllegalAccessException,
            NoSuchFieldException, InvocationTargetException {
        if (map != null) {
            Method mapRemove =
                map.getClass().getDeclaredMethod("remove",
                        ThreadLocal.class);
            mapRemove.setAccessible(true);
            Object[] table = (Object[]) internalTableField.get(map);
            int staleEntriesCount = 0;
            if (table != null) {
                for (int j =0; j < table.length; j++) {
                    if (table[j] != null) {
                        boolean potentialLeak = false;
                        // Check the key
                        Object key = ((Reference<?>) table[j]).get();
                        if (this.equals(key) || objectIsLoadedByThisOrChildClassLoader(key)) {
                            potentialLeak = true;
                            remove = true;
                        }
                        // Check the value
                        Field valueField =
                            table[j].getClass().getDeclaredField("value");
                        valueField.setAccessible(true);
                        Object value = valueField.get(table[j]);
                        if (this.equals(value) || objectIsLoadedByThisOrChildClassLoader(value)) {
                            potentialLeak = true;
                            remove = true;
                        }
                        if (potentialLeak) {
                            Object[] args = new Object[5];
                            args[0] = contextName;
                            if (key != null) {

                            if (value != null) {
                                args[3] = value.getClass().getCanonicalName();
                                args[4] = value.toString();
                                log.error(sm.getString(
                                        "webappClassLoader.checkThreadLocalsForLeaks",
                                        args));
                            } else {
                                if (log.isDebugEnabled()) {
                                    log.debug(sm.getString(
                                            "webappClassLoader.checkThreadLocalsForLeaksDebug",
                                            args));
                                    if (clearReferencesThreadLocals) {
                                        log.debug(sm.getString(
                                                "webappClassLoader.clearThreadLocalDebugClear"));
                                    }
                                }
                            } else {
                                log.error(sm.getString(
                                        "webappClassLoader.clearThreadLocal",
                                        args));
                                if (clearReferencesThreadLocals) {
                                    log.info(sm.getString(
                                            "webappClassLoader.clearThreadLocalClear"));
                                }
                            }
                            if (clearReferencesThreadLocals) {
                                if (key == null) {
                                  staleEntriesCount++;
                                } else {
                                  mapRemove.invoke(map, key);
                                }
                            }
                        }
                    }
                }
            }
            if (staleEntriesCount > 0) {
                Method mapRemoveStale =
                    map.getClass().getDeclaredMethod("expungeStaleEntries");
                mapRemoveStale.setAccessible(true);
                mapRemoveStale.invoke(map);
            }
        }
    }


        }
    }


    /**
     * @param o
     *            an instance may be null
     * @return true if o os either a Class or an object of a Class that was
     *         loaded by this ClassLoader.
     */
    private boolean objectIsLoadedByThisOrChildClassLoader(Object o) {
        if (o == null) {
            return false;
        }

        Class<?> clazz;
        if (o instanceof Class) {
            clazz = (Class<?>) o;
        } else {
            clazz = o.getClass();
        }

        for (ClassLoader cl = clazz.getClassLoader(); cl != null; cl = cl.getParent()) {
            if (cl == this) {
                return true;
            }
        }
        return false;
    }


    /**

Lines 669-676 Link Here

(-)java/org/apache/catalina/loader/WebappLoader.java (-2 lines)
669	((StandardContext) container).getClearReferencesStopThreads());	669	((StandardContext) container).getClearReferencesStopThreads());
670	classLoader.setClearReferencesStopTimerThreads(	670	classLoader.setClearReferencesStopTimerThreads(
671	((StandardContext) container).getClearReferencesStopTimerThreads());	671	((StandardContext) container).getClearReferencesStopTimerThreads());
672	classLoader.setClearReferencesThreadLocals(
673	((StandardContext) container).getClearReferencesThreadLocals());
674	}	672	}
675		673
676	for (int i = 0; i < repositories.length; i++) {	674	for (int i = 0; i < repositories.length; i++) {




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tomcat.util.threads;

import java.util.Collection;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * As task queue specifically designed to run with a thread pool executor.
 * The task queue is optimised to properly utilize threads within 
 * a thread pool executor. If you use a normal queue, the executor will spawn threads
 * when there are idle threads and you wont be able to force items unto the queue itself 
 * @author fhanik
 *
 */
public class TaskQueue extends LinkedBlockingQueue<Runnable> {

    private static final long serialVersionUID = 1L;

    private ThreadPoolExecutor parent = null;
    
    // no need to be volatile, the one times when we change and read it occur in
    // a single thread (the one that did stop a context and fired listeners)
    private Integer forcedRemainingCapacity = null;

    public TaskQueue() {
        super();
    }

    public TaskQueue(int capacity) {
        super(capacity);
    }

    public TaskQueue(Collection<? extends Runnable> c) {
        super(c);
    }

    public void setParent(ThreadPoolExecutor tp) {
        parent = tp;
    }
    
    public boolean force(Runnable o) {
        if ( parent.isShutdown() ) throw new RejectedExecutionException("Executor not running, can't force a command into the queue");
        return super.offer(o); //forces the item onto the queue, to be used if the task is rejected
    }

    public boolean force(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
        if ( parent.isShutdown() ) throw new RejectedExecutionException("Executor not running, can't force a command into the queue");
        return super.offer(o,timeout,unit); //forces the item onto the queue, to be used if the task is rejected
    }

    @Override
    public boolean offer(Runnable o) {
      //we can't do any checks
        if (parent==null) return super.offer(o);
        //we are maxed out on threads, simply queue the object
        if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
        //we have idle threads, just add it to the queue
        if (parent.getSubmittedCount()<(parent.getPoolSize())) return super.offer(o);
        //if we have less threads than maximum force creation of a new thread
        if (parent.getPoolSize()<parent.getMaximumPoolSize()) return false;
        //if we reached here, we need to add it to the queue
        return super.offer(o);
    }


    @Override
    public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
        Runnable runnable = super.poll(timeout, unit);
        if (runnable == null && parent != null) {
            // the poll timed out, it gives an opportunity to stop the current
            // thread if needed to avoid memory leaks.
            parent.stopCurrentThreadIfNeeded();
        }
        return runnable;
    }
    

    @Override
    public Runnable take() throws InterruptedException {
        if (parent != null && parent.currentThreadShouldBeStopped()) {
            return poll(parent.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS);
            //yes, this may return null (in case of timeout) which normally does not occur with take()
            //but the ThreadPoolExecutor implementation allows this
        }
        return super.take();
    }

    @Override
    public int remainingCapacity() {
        if(forcedRemainingCapacity != null) {
            // ThreadPoolExecutor.setCorePoolSize checks that
            // remainingCapacity==0 to allow to interrupt idle threads
            // I don't see why, but this hack allows to conform to this
            // "requirement"
            return forcedRemainingCapacity.intValue();
        }
        return super.remainingCapacity();
    }

    public void setForcedRemainingCapacity(Integer forcedRemainingCapacity) {
        this.forcedRemainingCapacity = forcedRemainingCapacity;
    }

}




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tomcat.util.threads;

/**
 * A Thread implementation that records the time at which it was created.
 * 
 * @author slaurent
 * 
 */
public class TaskThread extends Thread {

	private final long creationTime;

	public TaskThread(ThreadGroup group, Runnable target, String name) {
		super(group, target, name);
		this.creationTime = System.currentTimeMillis();
	}

	public TaskThread(ThreadGroup group, Runnable target, String name,
			long stackSize) {
		super(group, target, name, stackSize);
		this.creationTime = System.currentTimeMillis();
	}

	/**
	 * @return the time (in ms) at which this thread was created
	 */
	public final long getCreationTime() {
		return creationTime;
	}

}




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tomcat.util.threads;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * Simple task thread factory to use to create threads for an executor implementation.
 * @author fhanik
 *
 */
public class TaskThreadFactory implements ThreadFactory {
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    private final boolean daemon;
    private final int threadPriority;
    public TaskThreadFactory(String namePrefix, boolean daemon, int priority) {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        this.namePrefix = namePrefix;
        this.daemon = daemon;
        this.threadPriority = priority;
    }

    @Override
    public Thread newThread(Runnable r) {
        TaskThread t = new TaskThread(group, r, namePrefix + threadNumber.getAndIncrement());
        t.setDaemon(daemon);
        t.setPriority(threadPriority);
        return t;
    }

}




/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.tomcat.util.threads;

import java.lang.Thread.UncaughtExceptionHandler;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;

import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;

/**
 * Same as a java.util.concurrent.ThreadPoolExecutor but implements a much more efficient
 * {@link #getSubmittedCount()} method, to be used to properly handle the work queue.
 * If a RejectedExecutionHandler is not specified a default one will be configured
 * and that one will always throw a RejectedExecutionException
 * @author fhanik
 *
 */
public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor {
    private static final Log log = LogFactory.getLog(ThreadPoolExecutor.class);

    /**
     * The number of tasks submitted but not yet finished. This includes tasks
     * in the queue and tasks that have been handed to a worker thread but the
     * latter did not start executing the task yet.
     * This number is always greater or equal to {@link #getActiveCount()}.
     */
    private final AtomicInteger submittedCount = new AtomicInteger(0);
    private final AtomicLong lastContextStoppedTime = new AtomicLong(0L);

    /**
     * Most recent time in ms when a thread decided to kill itself to avoid
     * potential memory leaks. Useful to throttle the rate of renewals of
     * threads.
     */
    private final AtomicLong lastTimeThreadKilledItself = new AtomicLong(0L);

    /**
     * Delay in ms between 2 threads being renewed. If negative, do not renew threads.
     */
    private long threadRenewalDelay = 1000L;

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,
            RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, new RejectHandler());
    }

    public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new RejectHandler());
    }
    
    public long getThreadRenewalDelay() {
        return threadRenewalDelay;
    }

    public void setThreadRenewalDelay(long threadRenewalDelay) {
        this.threadRenewalDelay = threadRenewalDelay;
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        submittedCount.decrementAndGet();

        if (t == null) {
            stopCurrentThreadIfNeeded();
        }
    }

    /**
     * If the current thread was started before the last time when a context was
     * stopped, an exception is thrown so that the current thread is stopped.
     */
    protected void stopCurrentThreadIfNeeded() {
        if (currentThreadShouldBeStopped()) {
            long lastTime = lastTimeThreadKilledItself.longValue();
            if (lastTime + threadRenewalDelay < System.currentTimeMillis()) {
                if (lastTimeThreadKilledItself.compareAndSet(lastTime, System.currentTimeMillis() + 1)) {
                    // OK, it's really time to dispose of this thread
                    
                    final String msg = "Stopping thread " + Thread.currentThread().getName()
                            + " to avoid potential memory leaks after a context was stopped.";
                    Thread.currentThread().setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
                        @Override
                        public void uncaughtException(Thread t, Throwable e) {
                            // yes, swallow the exception
                            log.debug(msg);
                        }
                    });
                    throw new RuntimeException(msg);
                }
            }
        }
    }
    
    protected boolean currentThreadShouldBeStopped() {
        if (threadRenewalDelay >= 0 && Thread.currentThread() instanceof TaskThread) {
            TaskThread currentTaskThread = (TaskThread) Thread.currentThread();
            if (currentTaskThread.getCreationTime() < this.lastContextStoppedTime.longValue()) {
                return true;
            }
        }
        return false;
    }

    public int getSubmittedCount() {
        return submittedCount.get();
    }
    
    /**
     * {@inheritDoc}
     */
    @Override
    public void execute(Runnable command) {
        execute(command,0,TimeUnit.MILLISECONDS);
    }
    
    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the <tt>Executor</tt> implementation.
     * If no threads are available, it will be added to the work queue.
     * If the work queue is full, the system will wait for the specified 
     * time and it throw a RejectedExecutionException if the queue is still full after that.
     *
     * @param command the runnable task
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution - the queue is full
     * @throws NullPointerException if command or unit is null
     */
    public void execute(Runnable command, long timeout, TimeUnit unit) {
        submittedCount.incrementAndGet();
        try {
            super.execute(command);
        } catch (RejectedExecutionException rx) {
            if (super.getQueue() instanceof TaskQueue) {
                final TaskQueue queue = (TaskQueue)super.getQueue();
                try {
                    if (!queue.force(command, timeout, unit)) {
                        submittedCount.decrementAndGet();
                        throw new RejectedExecutionException("Queue capacity is full.");
                    }
                } catch (InterruptedException x) {
                    submittedCount.decrementAndGet();
                    Thread.interrupted();
                    throw new RejectedExecutionException(x);
                }
            } else {
                submittedCount.decrementAndGet();
                throw rx;
            }
            
        }
    }

    public void contextStopping() {
        this.lastContextStoppedTime.set(System.currentTimeMillis());

        // save the current pool parameters to restore them later
        int savedCorePoolSize = this.getCorePoolSize();
        TaskQueue taskQueue = getQueue() instanceof TaskQueue ? (TaskQueue) getQueue() : null;
        if (taskQueue != null) {
            // note by slaurent : quite oddly threadPoolExecutor.setCorePoolSize
            // checks that queue.remainingCapacity()==0. I did not understand
            // why, but to get the intended effect of waking up idle threads, I
            // temporarily fake this condition.
            taskQueue.setForcedRemainingCapacity(0);
        }

        // setCorePoolSize(0) wakes idle threads
        this.setCorePoolSize(0);

        // wait a little so that idle threads wake and poll the queue again,
        // this time always with a timeout (queue.poll() instead of queue.take())
        // even if we did not wait enough, TaskQueue.take() takes care of timing out
        // so that we are sure that all threads of the pool are renewed in a limited
        // time, something like (threadKeepAlive + longest request time)
        try {
            Thread.sleep(200L);
        } catch (InterruptedException e) {
            //yes, ignore
        }
        
        if (taskQueue != null) {
            // ok, restore the state of the queue and pool
            taskQueue.setForcedRemainingCapacity(null);
        }
        this.setCorePoolSize(savedCorePoolSize);
    }
    
    private static class RejectHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r,
                java.util.concurrent.ThreadPoolExecutor executor) {
            throw new RejectedExecutionException();
        }
        
    }


}




        not specified, the default value of <code>false</code> will be used.</p>
      </attribute>

      <attribute name="clearReferencesThreadLocals" required="false">
        <p>If <code>true</code>, Tomcat attempts to clear any ThreadLocal
        objects that are instances of classes loaded by this class loader.
        Failure to remove any such objects will result in a memory leak on web
        application stop, undeploy or reload.  If not specified, the default
        value of <code>false</code> will be used since the clearing of the
        ThreadLocal objects is not performed in a thread-safe manner.</p>
      </attribute>

      <attribute name="processTlds" required="false">
        <p>Whether the context should process TLDs on startup.  The default
        is true.  The false setting is intended for special cases
        that know in advance TLDs are not part of the webapp.</p>
      </attribute>

      <attribute name="renewThreadsWhenStoppingContext" required="false">
        <p>If <code>true</code>, when this context is stopped, Tomcat renews all
        the threads from the thread pool that was used to serve this context.
        This also requires that the 
        <code>ThreadLocalLeakPreventionListener</code> be configured in 
        <code>server.xml</code> and that the <code>threadRenewalDelay</code>
        property of the <code>Executor</code> be &gt;=0. If not specified, the 
        default value of <code>true</code> will be used.</p>
      </attribute>

      <attribute name="swallowOutput" required="false">
        <p>If the value of this flag is <code>true</code>, the bytes output to
        System.out and System.err by the web application will be redirected to

Lines 102-107 Link Here

(-)webapps/docs/config/executor.xml (+5 lines)
102	<p>(int) The number of milliseconds before an idle thread shutsdown, unless the number of active threads are less	102	<p>(int) The number of milliseconds before an idle thread shutsdown, unless the number of active threads are less
103	or equal to minSpareThreads. Default value is <code>60000</code>(1 minute)</p>	103	or equal to minSpareThreads. Default value is <code>60000</code>(1 minute)</p>
104	</attribute>	104	</attribute>
		105	<attribute name="threadRenewalDelay" required="false">
		106	<p>After a context is stopped, threads in the pool are renewed. To avoid renewing all threads at the same time,
		107	this delay is observed between 2 threads being renewed. Value is in ms, default value is 1000ms.
		108	If negative, threads are not renewed.</p>
		109	</attribute>
105	</attributes>	110	</attributes>
106		111
107		112

Return to bug 49159

Lines 750-762 Link Here

(-)java/org/apache/catalina/core/StandardContext.java (-29 / +14 lines)
750	private boolean clearReferencesStopTimerThreads = false;	750	private boolean clearReferencesStopTimerThreads = false;
751		751
752	/**	752	/**
753	* Should Tomcat attempt to clear any ThreadLocal objects that are instances	753	* Should Tomcat renew the threads of the thread pool when the application
754	* of classes loaded by this class loader. Failure to remove any such	754	* is stopped to avoid memory leaks because of uncleaned ThreadLocal
755	* objects will result in a memory leak on web application stop, undeploy or	755	* variables. This also requires that the threadRenewalDelay property of the
756	* reload. It is disabled by default since the clearing of the ThreadLocal	756	* StandardThreadExecutor of ThreadPoolExecutor be set to a positive value.
757	* objects is not performed in a thread-safe manner.
758	*/	757	*/
759	private boolean clearReferencesThreadLocals = false;	758	private boolean renewThreadsWhenStoppingContext = true;
760		759
761	// ----------------------------------------------------- Context Properties	760	// ----------------------------------------------------- Context Properties
762		761
Lines 2184-2214 Link Here
2184	}	2183	}
2185		2184
2186		2185
2187	/**	2186	public boolean getRenewThreadsWhenStoppingContext() {
2188	* Return the clearReferencesThreadLocals flag for this Context.	2187	return this.renewThreadsWhenStoppingContext;
2189	*/
2190	public boolean getClearReferencesThreadLocals() {
2191
2192	return (this.clearReferencesThreadLocals);
2193
2194	}	2188	}
2195		2189
2196		2190	public void setRenewThreadsWhenStoppingContext(boolean renewThreadsWhenStoppingContext) {
2197	/**	2191	boolean oldRenewThreadsWhenStoppingContext =
2198	* Set the clearReferencesStopThreads feature for this Context.	2192	this.renewThreadsWhenStoppingContext;
2199	*	2193	this.renewThreadsWhenStoppingContext = renewThreadsWhenStoppingContext;
2200	* @param clearReferencesStopThreads The new flag value	2194	support.firePropertyChange("renewThreadsWhenStoppingContext",
2201	*/	2195	oldRenewThreadsWhenStoppingContext,
2202	public void setClearReferencesThreadLocals(	2196	this.renewThreadsWhenStoppingContext);
2203	boolean clearReferencesThreadLocals) {
2204
2205	boolean oldClearReferencesThreadLocals =
2206	this.clearReferencesThreadLocals;
2207	this.clearReferencesThreadLocals = clearReferencesThreadLocals;
2208	support.firePropertyChange("clearReferencesStopThreads",
2209	oldClearReferencesThreadLocals,
2210	this.clearReferencesThreadLocals);
2211
2212	}	2197	}
2213		2198
2214		2199

Lines 372-392 Link Here

(-)webapps/docs/config/context.xml (-9 / +10 lines)
372	not specified, the default value of <code>false</code> will be used.</p>	372	not specified, the default value of <code>false</code> will be used.</p>
373	</attribute>	373	</attribute>
374		374
375	<attribute name="clearReferencesThreadLocals" required="false">
376	<p>If <code>true</code>, Tomcat attempts to clear any ThreadLocal
377	objects that are instances of classes loaded by this class loader.
378	Failure to remove any such objects will result in a memory leak on web
379	application stop, undeploy or reload. If not specified, the default
380	value of <code>false</code> will be used since the clearing of the
381	ThreadLocal objects is not performed in a thread-safe manner.</p>
382	</attribute>
383
384	<attribute name="processTlds" required="false">	375	<attribute name="processTlds" required="false">
385	<p>Whether the context should process TLDs on startup. The default	376	<p>Whether the context should process TLDs on startup. The default
386	is true. The false setting is intended for special cases	377	is true. The false setting is intended for special cases
387	that know in advance TLDs are not part of the webapp.</p>	378	that know in advance TLDs are not part of the webapp.</p>
388	</attribute>	379	</attribute>
389		380
		381	<attribute name="renewThreadsWhenStoppingContext" required="false">
		382	<p>If <code>true</code>, when this context is stopped, Tomcat renews all
		383	the threads from the thread pool that was used to serve this context.
		384	This also requires that the
		385	<code>ThreadLocalLeakPreventionListener</code> be configured in
		386	<code>server.xml</code> and that the <code>threadRenewalDelay</code>
		387	property of the <code>Executor</code> be >=0. If not specified, the
		388	default value of <code>true</code> will be used.</p>
		389	</attribute>
		390
390	<attribute name="swallowOutput" required="false">	391	<attribute name="swallowOutput" required="false">
391	<p>If the value of this flag is <code>true</code>, the bytes output to	392	<p>If the value of this flag is <code>true</code>, the bytes output to
392	System.out and System.err by the web application will be redirected to	393	System.out and System.err by the web application will be redirected to

Line 0 Link Here

(-)java/org/apache/catalina/core/ThreadLocalLeakPreventionListener.java (+222 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*/
		17
		18	package org.apache.catalina.core;
		19
		20	import java.util.concurrent.Executor;
		21
		22	import org.apache.catalina.Container;
		23	import org.apache.catalina.ContainerEvent;
		24	import org.apache.catalina.ContainerListener;
		25	import org.apache.catalina.Context;
		26	import org.apache.catalina.Engine;
		27	import org.apache.catalina.Host;
		28	import org.apache.catalina.Lifecycle;
		29	import org.apache.catalina.LifecycleEvent;
		30	import org.apache.catalina.LifecycleListener;
		31	import org.apache.catalina.Server;
		32	import org.apache.catalina.Service;
		33	import org.apache.catalina.connector.Connector;
		34	import org.apache.coyote.ProtocolHandler;
		35	import org.apache.coyote.ajp.AjpAprProtocol;
		36	import org.apache.coyote.ajp.AjpProtocol;
		37	import org.apache.coyote.http11.Http11AprProtocol;
		38	import org.apache.coyote.http11.Http11NioProtocol;
		39	import org.apache.coyote.http11.Http11Protocol;
		40	import org.apache.juli.logging.Log;
		41	import org.apache.juli.logging.LogFactory;
		42	import org.apache.tomcat.util.threads.ThreadPoolExecutor;
		43
		44	/**
		45	* A {@link LifecycleListener} that triggers the renewal of threads in Executor
		46	* pools when a {@link Context} is being stopped to avoid thread-local related
		47	* memory leaks.<br/>
		48	* Note : active threads will be renewed one by one when they come back to the
		49	* pool after executing their task, see
		50	* {@link org.apache.tomcat.util.threads.ThreadPoolExecutor}.afterExecute().<br/>
		51	*
		52	* This listener must be declared in server.xml to be active, and the connectors
		53	* must use an Executor instead of their internal thread pool.
		54	*
		55	* @author slaurent
		56	*
		57	*/
		58	public class ThreadLocalLeakPreventionListener implements LifecycleListener, ContainerListener {
		59	private static final Log log = LogFactory.getLog(ThreadLocalLeakPreventionListener.class);
		60
		61	/**
		62	* Listens for {@link LifecycleEvent} for the start of the {@link Server} to
		63	* initialize itself and then for after_stop events of each {@link Context}.
		64	*/
65	@Override
66	public void lifecycleEvent(LifecycleEvent event) {
67	try {
68	Lifecycle lifecycle = event.getLifecycle();
69	if (Lifecycle.AFTER_START_EVENT.equals(event.getType()) && lifecycle instanceof Server) {
70	// when the server starts, we register ourself as listener for
71	// all context
72	// as well as container event listener so that we know when new
73	// Context are deployed
74	Server server = (Server) lifecycle;
75	registerListenersForServer(server);
76	}
77
78	if (Lifecycle.AFTER_STOP_EVENT.equals(event.getType()) && lifecycle instanceof Context) {
79	stopIdleThreads((Context) lifecycle);
80	}
81	} catch (Exception e) {
82	log.error("Exception processing event " + event, e);
83	}
84	}
85
86	@Override
87	public void containerEvent(ContainerEvent event) {
88	try {
89	String type = event.getType();
90	if (Container.ADD_CHILD_EVENT.equals(type)) {
91	processContainerAddChild(event.getContainer(), (Container) event.getData());
92	} else if (Container.REMOVE_CHILD_EVENT.equals(type)) {
93	processContainerRemoveChild(event.getContainer(), (Container) event.getData());
94	}
95	} catch (Exception e) {
96	log.error("Exception processing event " + event, e);
97	}
98
99	}
100
101	private void registerListenersForServer(Server server) {
102	for (Service service : server.findServices()) {
103	Engine engine = (Engine) service.getContainer();
104	engine.addContainerListener(this);
105	registerListenersForEngine(engine);
106	}
107
108	}
109
110	private void registerListenersForEngine(Engine engine) {
111	for (Container hostContainer : engine.findChildren()) {
112	Host host = (Host) hostContainer;
113	host.addContainerListener(this);
114	registerListenersForHost(host);
115	}
116	}
117
118	private void registerListenersForHost(Host host) {
119	for (Container contextContainer : host.findChildren()) {
120	Context context = (Context) contextContainer;
121	registerContextListener(context);
122	}
123	}
124
125	private void registerContextListener(Context context) {
126	if (context instanceof Lifecycle) {
127	((Lifecycle) context).addLifecycleListener(this);
128	}
129	}
130
131	protected void processContainerAddChild(Container parent, Container child) {
132	if (log.isDebugEnabled())
133	log.debug("Process addChild[parent=" + parent + ",child=" + child + "]");
134
135	try {
136	if (child instanceof Context) {
137	registerContextListener((Context) child);
138	} else if (child instanceof Engine) {
139	registerListenersForEngine((Engine) child);
140	} else if (child instanceof Host) {
141	registerListenersForHost((Host) child);
142	}
143	} catch (Throwable t) {
144	log.error("processContainerAddChild: Throwable", t);
145	}
146
147	}
148
149	protected void processContainerRemoveChild(Container parent, Container child) {
150
151	if (log.isDebugEnabled())
152	log.debug("Process removeChild[parent=" + parent + ",child=" + child + "]");
153
154	try {
155	if (child instanceof Context) {
156	Context context = (Context) child;
157	if (context instanceof Lifecycle) {
158	((Lifecycle) context).removeLifecycleListener(this);
159	}
160	} else if (child instanceof Host) {
161	Host host = (Host) child;
162	host.removeContainerListener(this);
163	} else if (child instanceof Engine) {
164	Engine engine = (Engine) child;
165	engine.removeContainerListener(this);
166	}
167	} catch (Throwable t) {
168	log.error("processContainerRemoveChild: Throwable", t);
169	}
170
171	}
172
173	/**
174	* Updates each ThreadPoolExecutor with the current time, which is the time
175	* when a context is being stopped.
176	*
177	* @param context
178	* the context being stopped, used to discover all the Connectors
179	* of its parent Service.
180	*/
181	private void stopIdleThreads(Context context) {
182	if (context instanceof StandardContext && !((StandardContext) context).getRenewThreadsWhenStoppingContext()) {
183	log.debug("Not renewing threads when the context is stopping, it is configured not to do it.");
184	return;
185	}
186
187	Engine engine = (Engine) context.getParent().getParent();
188	Service service = engine.getService();
189	Connector[] connectors = service.findConnectors();
190	if (connectors != null) {
191	for (Connector connector : connectors) {
192	ProtocolHandler handler = connector.getProtocolHandler();
193	Executor executor = null;
194
195	// unfortunately there's no getExecutor() method in
196	// ProtocolHandler
197	// we have to check each known implementation
198
199	if (handler instanceof Http11Protocol) {
200	executor = ((Http11Protocol) handler).getExecutor();
201	} else if (handler instanceof AjpProtocol) {
202	executor = ((AjpProtocol) handler).getExecutor();
203	} else if (handler instanceof AjpAprProtocol) {
204	executor = ((AjpAprProtocol) handler).getExecutor();
205	} else if (handler instanceof Http11AprProtocol) {
206	executor = ((Http11AprProtocol) handler).getExecutor();
207	} else if (handler instanceof Http11NioProtocol) {
208	executor = ((Http11NioProtocol) handler).getExecutor();
209	}
210
211	if (executor instanceof StandardThreadExecutor) {
212	StandardThreadExecutor stdThreadExecutor = (StandardThreadExecutor) executor;
213	stdThreadExecutor.contextStopping();
214	} else if (executor instanceof ThreadPoolExecutor) {
215	ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
216	threadPoolExecutor.contextStopping();
217	}
218
219	}
220	}
221	}
222	}

Line 0 Link Here

(-)java/org/apache/tomcat/util/threads/TaskQueue.java (+121 lines)
		1	/*
		2	* Licensed to the Apache Software Foundation (ASF) under one or more
		3	* contributor license agreements. See the NOTICE file distributed with
		4	* this work for additional information regarding copyright ownership.
		5	* The ASF licenses this file to You under the Apache License, Version 2.0
		6	* (the "License"); you may not use this file except in compliance with
		7	* the License. You may obtain a copy of the License at
		8	*
		9	* http://www.apache.org/licenses/LICENSE-2.0
		10	*
		11	* Unless required by applicable law or agreed to in writing, software
		12	* distributed under the License is distributed on an "AS IS" BASIS,
		13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		14	* See the License for the specific language governing permissions and
		15	* limitations under the License.
		16	*/
		17	package org.apache.tomcat.util.threads;
		18
		19	import java.util.Collection;
		20	import java.util.concurrent.LinkedBlockingQueue;
		21	import java.util.concurrent.RejectedExecutionException;
		22	import java.util.concurrent.TimeUnit;
		23
		24	/**
		25	* As task queue specifically designed to run with a thread pool executor.
		26	* The task queue is optimised to properly utilize threads within
		27	* a thread pool executor. If you use a normal queue, the executor will spawn threads
		28	* when there are idle threads and you wont be able to force items unto the queue itself
		29	* @author fhanik
		30	*
		31	*/
		32	public class TaskQueue extends LinkedBlockingQueue<Runnable> {
		33
		34	private static final long serialVersionUID = 1L;
		35
		36	private ThreadPoolExecutor parent = null;
		37
		38	// no need to be volatile, the one times when we change and read it occur in
		39	// a single thread (the one that did stop a context and fired listeners)
		40	private Integer forcedRemainingCapacity = null;
		41
		42	public TaskQueue() {
		43	super();
		44	}
		45
		46	public TaskQueue(int capacity) {
		47	super(capacity);
		48	}
		49
		50	public TaskQueue(Collection<? extends Runnable> c) {
		51	super(c);
		52	}
		53
		54	public void setParent(ThreadPoolExecutor tp) {
		55	parent = tp;
		56	}
		57
		58	public boolean force(Runnable o) {
		59	if ( parent.isShutdown() ) throw new RejectedExecutionException("Executor not running, can't force a command into the queue");
		60	return super.offer(o); //forces the item onto the queue, to be used if the task is rejected
		61	}
		62
		63	public boolean force(Runnable o, long timeout, TimeUnit unit) throws InterruptedException {
		64	if ( parent.isShutdown() ) throw new RejectedExecutionException("Executor not running, can't force a command into the queue");
65	return super.offer(o,timeout,unit); //forces the item onto the queue, to be used if the task is rejected
66	}
67
68	@Override
69	public boolean offer(Runnable o) {
70	//we can't do any checks
71	if (parent==null) return super.offer(o);
72	//we are maxed out on threads, simply queue the object
73	if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
74	//we have idle threads, just add it to the queue
75	if (parent.getSubmittedCount()<(parent.getPoolSize())) return super.offer(o);
76	//if we have less threads than maximum force creation of a new thread
77	if (parent.getPoolSize()<parent.getMaximumPoolSize()) return false;
78	//if we reached here, we need to add it to the queue
79	return super.offer(o);
80	}
81
82
83	@Override
84	public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
85	Runnable runnable = super.poll(timeout, unit);
86	if (runnable == null && parent != null) {
87	// the poll timed out, it gives an opportunity to stop the current
88	// thread if needed to avoid memory leaks.
89	parent.stopCurrentThreadIfNeeded();
90	}
91	return runnable;
92	}
93
94
95	@Override
96	public Runnable take() throws InterruptedException {
97	if (parent != null && parent.currentThreadShouldBeStopped()) {
98	return poll(parent.getKeepAliveTime(TimeUnit.MILLISECONDS), TimeUnit.MILLISECONDS);
99	//yes, this may return null (in case of timeout) which normally does not occur with take()
100	//but the ThreadPoolExecutor implementation allows this
101	}
102	return super.take();
103	}
104
105	@Override
106	public int remainingCapacity() {
107	if(forcedRemainingCapacity != null) {
108	// ThreadPoolExecutor.setCorePoolSize checks that
109	// remainingCapacity==0 to allow to interrupt idle threads
110	// I don't see why, but this hack allows to conform to this
111	// "requirement"
112	return forcedRemainingCapacity.intValue();
113	}
114	return super.remainingCapacity();
115	}
116
117	public void setForcedRemainingCapacity(Integer forcedRemainingCapacity) {
118	this.forcedRemainingCapacity = forcedRemainingCapacity;
119	}
120
121	}