org.eclipse.jetty.util.thread

## Class ExecutorThreadPool

- java.lang.Object
- - org.eclipse.jetty.util.component.AbstractLifeCycle
  - - org.eclipse.jetty.util.thread.ExecutorThreadPool

- All Implemented Interfaces:
    LifeCycle, ThreadPool

      public class ExecutorThreadPool
      extends AbstractLifeCycle
      implements ThreadPool, LifeCycle

  Jetty ThreadPool using java 5 ThreadPoolExecutor This class wraps a `ExecutorService` as a `ThreadPool` and `LifeCycle` interfaces so that it may be used by the Jetty `org.eclipse.jetty.server.Server`

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

      `AbstractLifeCycle.AbstractLifeCycleListener`

    - ### Nested classes/interfaces inherited from interface org.eclipse.jetty.util.thread.ThreadPool

      `ThreadPool.SizedThreadPool`

    - ### Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.LifeCycle

      `LifeCycle.Listener`

  - ### Field Summary

    - ### Fields inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

      `_listeners, FAILED, RUNNING, STARTED, STARTING, STOPPED, STOPPING`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ExecutorThreadPool()` Wraps an `ThreadPoolExecutor`.
    `ExecutorThreadPool(java.util.concurrent.ExecutorService executor)`
    `ExecutorThreadPool(int queueSize)` Wraps an `ThreadPoolExecutor`.
    `ExecutorThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime)` Wraps an `ThreadPoolExecutor` using an unbounded `LinkedBlockingQueue` is used for the jobs queue;
    `ExecutorThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit)` Wraps an `ThreadPoolExecutor` using an unbounded `LinkedBlockingQueue` is used for the jobs queue.
    `ExecutorThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, java.util.concurrent.TimeUnit unit, java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue)` Wraps an `ThreadPoolExecutor`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `dispatch(java.lang.Runnable job)`
    `protected void` | `doStop()`
    `int` | `getIdleThreads()`
    `int` | `getThreads()`
    `boolean` | `isLowOnThreads()`
    `void` | `join()` Blocks until the thread pool is `stopped`.

    - ### Methods inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

      `addLifeCycleListener, doStart, getState, getState, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stop`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.eclipse.jetty.util.component.LifeCycle

      `addLifeCycleListener, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stop`

- - ### Constructor Detail

    - #### ExecutorThreadPool

          public ExecutorThreadPool(java.util.concurrent.ExecutorService executor)

    - #### ExecutorThreadPool

          public ExecutorThreadPool()

      Wraps an `ThreadPoolExecutor`. Max pool size is 256, pool thread timeout after 60 seconds and an unbounded `LinkedBlockingQueue` is used for the job queue;

    - #### ExecutorThreadPool

          public ExecutorThreadPool(int queueSize)

      Wraps an `ThreadPoolExecutor`. Max pool size is 256, pool thread timeout after 60 seconds, and core pool size is 32 when queueSize >= 0.
      Parameters:
        `queueSize` - can be -1 for using an unbounded `LinkedBlockingQueue`, 0 for using a `SynchronousQueue`, greater than 0 for using a `ArrayBlockingQueue` of the given size.

    - #### ExecutorThreadPool

          public ExecutorThreadPool(int corePoolSize,
                            int maximumPoolSize,
                            long keepAliveTime)

      Wraps an `ThreadPoolExecutor` using an unbounded `LinkedBlockingQueue` is used for the jobs queue;
      Parameters:
        `corePoolSize` - must be equal to maximumPoolSize
        `maximumPoolSize` - the maximum number of threads to allow in the pool
        `keepAliveTime` - the max time a thread can remain idle, in milliseconds

    - #### ExecutorThreadPool

          public ExecutorThreadPool(int corePoolSize,
                            int maximumPoolSize,
                            long keepAliveTime,
                            java.util.concurrent.TimeUnit unit)

      Wraps an `ThreadPoolExecutor` using an unbounded `LinkedBlockingQueue` is used for the jobs queue.
      Parameters:
        `corePoolSize` - must be equal to maximumPoolSize
        `maximumPoolSize` - the maximum number of threads to allow in the pool
        `keepAliveTime` - the max time a thread can remain idle
        `unit` - the unit for the keepAliveTime

    - #### ExecutorThreadPool

          public ExecutorThreadPool(int corePoolSize,
                            int maximumPoolSize,
                            long keepAliveTime,
                            java.util.concurrent.TimeUnit unit,
                            java.util.concurrent.BlockingQueue<java.lang.Runnable> workQueue)

      Wraps an `ThreadPoolExecutor`
      Parameters:
        `corePoolSize` - the number of threads to keep in the pool, even if they are idle
        `maximumPoolSize` - the maximum number of threads to allow in the pool
        `keepAliveTime` - the max time a thread can remain idle
        `unit` - the unit for the keepAliveTime
        `workQueue` - the queue to use for holding tasks before they are executed

  - ### Method Detail

    - #### dispatch

          public boolean dispatch(java.lang.Runnable job)

      Specified by:
        `dispatch` in interface `ThreadPool`

    - #### getIdleThreads

          public int getIdleThreads()

      Specified by:
        `getIdleThreads` in interface `ThreadPool`
      Returns:
        The number of idle threads in the pool

    - #### getThreads

          public int getThreads()

      Specified by:
        `getThreads` in interface `ThreadPool`
      Returns:
        The total number of threads currently in the pool

    - #### isLowOnThreads

          public boolean isLowOnThreads()

      Specified by:
        `isLowOnThreads` in interface `ThreadPool`
      Returns:
        True if the pool is low on threads

    - #### join

          public void join()
                    throws java.lang.InterruptedException

      Description copied from interface: `ThreadPool`
      Blocks until the thread pool is `stopped`.
      Specified by:
        `join` in interface `ThreadPool`
      Throws:
        `java.lang.InterruptedException`

    - #### doStop

          protected void doStop()
                         throws java.lang.Exception

      Overrides:
        `doStop` in class `AbstractLifeCycle`
      Throws:
        `java.lang.Exception`

Copyright © 2013 FuseSource, Corp.. All Rights Reserved.