Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   * 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
  * 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 static org.jboss.web.CoyoteMessages.MESSAGES;
Same as a java.util.concurrent.ThreadPoolExecutor but implements a much more efficient 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

 public class ThreadPoolExecutor extends java.util.concurrent.ThreadPoolExecutor {

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 java.util.concurrent.ThreadPoolExecutor.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.
     public ThreadPoolExecutor(int corePoolSizeint maximumPoolSizelong keepAliveTimeTimeUnit unitBlockingQueue<RunnableworkQueueRejectedExecutionHandler handler) {
     public ThreadPoolExecutor(int corePoolSizeint maximumPoolSizelong keepAliveTimeTimeUnit unitBlockingQueue<RunnableworkQueueThreadFactory threadFactory,
             RejectedExecutionHandler handler) {
     public ThreadPoolExecutor(int corePoolSizeint maximumPoolSizelong keepAliveTimeTimeUnit unitBlockingQueue<RunnableworkQueueThreadFactory threadFactory) {
         super(corePoolSizemaximumPoolSizekeepAliveTimeunitworkQueuethreadFactorynew RejectHandler());
     public ThreadPoolExecutor(int corePoolSizeint maximumPoolSizelong keepAliveTimeTimeUnit unitBlockingQueue<RunnableworkQueue) {
         super(corePoolSizemaximumPoolSizekeepAliveTimeunitworkQueuenew RejectHandler());
     public long getThreadRenewalDelay() {
         return ;
     public void setThreadRenewalDelay(long threadRenewalDelay) {
         this. = threadRenewalDelay;
     protected void afterExecute(Runnable rThrowable t) {
         if (t == null) {

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 = .longValue();
            if (lastTime +  < System.currentTimeMillis()) {
                if (.compareAndSet(lastTime,
                        System.currentTimeMillis() + 1)) {
                    // OK, it's really time to dispose of this thread
                    final String msg = .threadStopped(Thread.currentThread().getName());
                            new UncaughtExceptionHandler() {
                                public void uncaughtException(Thread t,
                                        Throwable e) {
                                    // yes, swallow the exception
                    throw new RuntimeException(msg);
    protected boolean currentThreadShouldBeStopped() {
        if ( >= 0
            && Thread.currentThread() instanceof TaskThread) {
            TaskThread currentTaskThread = (TaskThread) Thread.currentThread();
            if (currentTaskThread.getCreationTime() <
                    this..longValue()) {
                return true;
        return false;
    public int getSubmittedCount() {
        return .get();

    public void execute(Runnable command) {

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 Executor 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.

command the runnable task
java.util.concurrent.RejectedExecutionException if this task cannot be accepted for execution - the queue is full
java.lang.NullPointerException if command or unit is null
    public void execute(Runnable commandlong timeoutTimeUnit unit) {
        try {
        } catch (RejectedExecutionException rx) {
            if (super.getQueue() instanceof TaskQueue) {
                final TaskQueue queue = (TaskQueue)super.getQueue();
                try {
                    if (!queue.force(commandtimeoutunit)) {
                        throw new RejectedExecutionException("Queue capacity is full.");
                } catch (InterruptedException x) {
                    throw new RejectedExecutionException(x);
            } else {
                throw rx;
    public void contextStopping() {
        // save the current pool parameters to restore them later
        int savedCorePoolSize = this.getCorePoolSize();
        TaskQueue taskQueue =
                getQueue() instanceof TaskQueue ? (TaskQueuegetQueue() : 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.
        // setCorePoolSize(0) wakes idle threads
        // 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 {
        } catch (InterruptedException e) {
            // yes, ignore
        if (taskQueue != null) {
            // ok, restore the state of the queue and pool
    private static class RejectHandler implements RejectedExecutionHandler {
        public void rejectedExecution(Runnable r,
                java.util.concurrent.ThreadPoolExecutor executor) {
            throw new RejectedExecutionException();
New to GrepCode? Check out our FAQ X