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
   *
   *      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;
 
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(s):
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 Runnablec) {
         super(c);
     }
 
     public void setParent(ThreadPoolExecutor tp) {
          = tp;
     }
 
     public boolean force(Runnable o) {
         if ( .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 olong timeoutTimeUnit unitthrows InterruptedException {
         if ( .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 (==nullreturn super.offer(o);
         //we are maxed out on threads, simply queue the object
         if (.getPoolSize() == .getMaximumPoolSize()) return super.offer(o);
         //we have idle threads, just add it to the queue
         if (.getSubmittedCount()<(.getPoolSize())) return super.offer(o);
         //if we have less threads than maximum force creation of a new thread
         if (.getPoolSize()<.getMaximumPoolSize()) return false;
         //if we reached here, we need to add it to the queue
         return super.offer(o);
     }
 
 
     @Override
     public Runnable poll(long timeoutTimeUnit unit)
             throws InterruptedException {
         Runnable runnable = super.poll(timeoutunit);
         if (runnable == null &&  != null) {
             // the poll timed out, it gives an opportunity to stop the current
             // thread if needed to avoid memory leaks.
             .stopCurrentThreadIfNeeded();
         }
         return runnable;
     }
 
     @Override
     public Runnable take() throws InterruptedException {
         if ( != null && .currentThreadShouldBeStopped()) {
             return poll(.getKeepAliveTime(.),
                     .);
            // 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 ( != 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 .intValue();
        }
        return super.remainingCapacity();
    }
    public void setForcedRemainingCapacity(Integer forcedRemainingCapacity) {
        this. = forcedRemainingCapacity;
    }
New to GrepCode? Check out our FAQ X