View Javadoc

    1   // ========================================================================
    2   // Copyright 2004-2005 Mort Bay Consulting Pty. Ltd.
    3   // ------------------------------------------------------------------------
    4   // Licensed under the Apache License, Version 2.0 (the "License");
    5   // you may not use this file except in compliance with the License.
    6   // You may obtain a copy of the License at
    7   // http://www.apache.org/licenses/LICENSE-2.0
    8   // Unless required by applicable law or agreed to in writing, software
    9   // distributed under the License is distributed on an "AS IS" BASIS,
    10  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11  // See the License for the specific language governing permissions and
    12  // limitations under the License.
    13  // ========================================================================
    14
    15  package org.mortbay.thread.concurrent;
    16
    17  import java.util.concurrent.ArrayBlockingQueue;
    18  import java.util.concurrent.BlockingQueue;
    19  import java.util.concurrent.LinkedBlockingQueue;
    20  import java.util.concurrent.RejectedExecutionException;
    21  import java.util.concurrent.RejectedExecutionHandler;
    22  import java.util.concurrent.SynchronousQueue;
    23  import java.util.concurrent.ThreadFactory;
    24  import java.util.concurrent.ThreadPoolExecutor;
    25  import java.util.concurrent.TimeUnit;
    26
    27  import org.mortbay.component.LifeCycle;
    28  import org.mortbay.log.Log;
    29
    30  /* ------------------------------------------------------------ */
    31  /** Jetty ThreadPool using java 5 ThreadPoolExecutor
    32   * This class wraps a {@link ThreadPoolExecutor} with the {@link org.mortbay.thread.ThreadPool} and
    33   * {@link LifeCycle} interfaces so that it may be used by the Jetty {@link org.mortbay.jetty.Server}
    34   *
    35   * @author gregw
    36   *
    37   */
    38  public class ThreadPool extends ThreadPoolExecutor implements org.mortbay.thread.ThreadPool, LifeCycle
    39  {
    40
    41      /* ------------------------------------------------------------ */
    42      /** Default constructor.
    43       * Core size is 32, max pool size is 256, pool thread timeout after 60 seconds and
    44       * an unbounded {@link LinkedBlockingQueue} is used for the job queue;
    45       */
    46      public ThreadPool()
    47      {
    48          super(32,256,60,TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());
    49      }
    50
    51      /* ------------------------------------------------------------ */
    52      /** Default constructor.
    53       * Core size is 32, max pool size is 256, pool thread timeout after 60 seconds
    54       * @param queueSize if -1, an unbounded {@link LinkedBlockingQueue} is used, if 0 then a
    55       * {@link SynchronousQueue} is used, other a {@link ArrayBlockingQueue} of the given size is used.
    56       */
    57      public ThreadPool(int queueSize)
    58      {
    59          super(32,256,60,TimeUnit.SECONDS,
    60                  queueSize<0?new LinkedBlockingQueue<Runnable>()
    61                          : (queueSize==0?new SynchronousQueue<Runnable>()
    62                                  :new ArrayBlockingQueue<Runnable>(queueSize)));
    63      }
    64
    65      /* ------------------------------------------------------------ */
    66      /** Size constructor.
    67       * an unbounded {@link LinkedBlockingQueue} is used for the jobs queue;
    68       */
    69      public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit)
    70      {
    71          super(corePoolSize,maximumPoolSize,keepAliveTime,unit,new LinkedBlockingQueue<Runnable>());
    72      }
    73
    74      /* ------------------------------------------------------------ */
    75      public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
    76      {
    77          super(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue);
    78      }
    79
    80      /* ------------------------------------------------------------ */
    81      public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
    82      {
    83          super(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,handler);
    84      }
    85
    86      /* ------------------------------------------------------------ */
    87      public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
    88      {
    89          super(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);
    90      }
    91
    92      /* ------------------------------------------------------------ */
    93      public ThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
    94      {
    95          super(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory);
    96      }
    97
    98      /* ------------------------------------------------------------ */
    99      public boolean dispatch(Runnable job)
    100     {
    101         try
    102         {
    103             execute(job);
    104             return true;
    105         }
    106         catch(RejectedExecutionException e)
    107         {
    108             Log.warn(e);
    109             return false;
    110         }
    111     }
    112
    113     /* ------------------------------------------------------------ */
    114     public int getIdleThreads()
    115     {
    116         return getPoolSize()-getActiveCount();
    117     }
    118
    119     /* ------------------------------------------------------------ */
    120     public int getThreads()
    121     {
    122         return getPoolSize();
    123     }
    124
    125     /* ------------------------------------------------------------ */
    126     public boolean isLowOnThreads()
    127     {
    128         return getActiveCount()>=getMaximumPoolSize();
    129     }
    130
    131     /* ------------------------------------------------------------ */
    132     public void join() throws InterruptedException
    133     {
    134         this.awaitTermination(Long.MAX_VALUE,TimeUnit.MILLISECONDS);
    135     }
    136
    137     /* ------------------------------------------------------------ */
    138     public boolean isFailed()
    139     {
    140         return false;
    141     }
    142
    143     /* ------------------------------------------------------------ */
    144     public boolean isRunning()
    145     {
    146         return !isTerminated() && !isTerminating();
    147     }
    148
    149     /* ------------------------------------------------------------ */
    150     public boolean isStarted()
    151     {
    152         return !isTerminated() && !isTerminating();
    153     }
    154
    155     /* ------------------------------------------------------------ */
    156     public boolean isStarting()
    157     {
    158         return false;
    159     }
    160
    161     /* ------------------------------------------------------------ */
    162     public boolean isStopped()
    163     {
    164         return isTerminated();
    165     }
    166
    167     /* ------------------------------------------------------------ */
    168     public boolean isStopping()
    169     {
    170         return isTerminating();
    171     }
    172
    173     /* ------------------------------------------------------------ */
    174     public void start() throws Exception
    175     {
    176         if (isTerminated() || isTerminating() || isShutdown())
    177             throw new IllegalStateException("Cannot restart");
    178     }
    179
    180     /* ------------------------------------------------------------ */
    181     public void stop() throws Exception
    182     {
    183         super.shutdown();
    184         if (!super.awaitTermination(60,TimeUnit.SECONDS))
    185             super.shutdownNow();
    186     }
    187
    188     /* ------------------------------------------------------------ */
    189     public void addLifeCycleListener(LifeCycle.Listener listener)
    190     {
    191         throw new UnsupportedOperationException();
    192     }
    193
    194     /* ------------------------------------------------------------ */
    195     public void removeLifeCycleListener(LifeCycle.Listener listener)
    196     {
    197     }
    198
    199 }