Package org.eclipse.jetty.util.thread

Class ReservedThreadExecutor

  • All Implemented Interfaces:
    java.util.concurrent.Executor, Dumpable, LifeCycle, TryExecutor
    @ManagedObject("A pool for reserved threads")
public class ReservedThreadExecutor
extends AbstractLifeCycle
implements TryExecutor, Dumpable

    A TryExecutor using pre-allocated/reserved threads from an external Executor.

    Calls to tryExecute(Runnable) on ReservedThreadExecutor will either succeed with a reserved thread immediately being assigned the task, or fail if no reserved thread is available.

    Threads are reserved lazily, with new reserved threads being allocated from the external Executor passed to the constructor. Whenever 1 or more reserved threads have been idle for more than getIdleTimeoutMs() then one reserved thread will return to the external Executor.

    • Field Detail

      • LOG

        private static final Logger LOG

      • DEFAULT_IDLE_TIMEOUT

        private static final long DEFAULT_IDLE_TIMEOUT

      • STOP

        private static final java.lang.Runnable STOP

      • _executor

        private final java.util.concurrent.Executor _executor

      • _capacity

        private final int _capacity

      • _queue

        private final java.util.concurrent.SynchronousQueue<java.lang.Runnable> _queue

      • _lastEmptyTime

        private final java.util.concurrent.atomic.AtomicLong _lastEmptyTime

      • _idleTimeNanos

        private long _idleTimeNanos

    • Constructor Detail

      • ReservedThreadExecutor

        public ReservedThreadExecutor​(java.util.concurrent.Executor executor,
                              int capacity)
        Parameters:
        executor - The executor to use to obtain threads
        capacity - The number of threads to preallocate. If less than 0 then capacity is calculated based on a heuristic from the number of available processors and thread pool size.

    • Method Detail

      • reservedThreads

        private static int reservedThreads​(java.util.concurrent.Executor executor,
                                   int capacity)
        Parameters:
        executor - The executor to use to obtain threads
        capacity - The number of threads to preallocate, If less than 0 then capacity is calculated based on a heuristic from the number of available processors and thread pool size.
        Returns:
        the number of reserved threads that would be used by a ReservedThreadExecutor constructed with these arguments.

      • getExecutor

        public java.util.concurrent.Executor getExecutor()

      • getCapacity

        @ManagedAttribute(value="max number of reserved threads",
                  readonly=true)
public int getCapacity()
        Returns:
        the maximum number of reserved threads

      • setIdleTimeout

        public void setIdleTimeout​(long idleTime,
                           java.util.concurrent.TimeUnit idleTimeUnit)
        Set the idle timeout for shrinking the reserved thread pool
        Parameters:
        idleTime - Time to wait before shrinking, or 0 for default timeout.
        idleTimeUnit - Time units for idle timeout

      • doStart

        public void doStart()
             throws java.lang.Exception
        Overrides:
        doStart in class AbstractLifeCycle
        Throws:
        java.lang.Exception

      • doStop

        public void doStop()
            throws java.lang.Exception
        Overrides:
        doStop in class AbstractLifeCycle
        Throws:
        java.lang.Exception

      • execute

        public void execute​(java.lang.Runnable task)
             throws java.util.concurrent.RejectedExecutionException
        Specified by:
        execute in interface java.util.concurrent.Executor
        Specified by:
        execute in interface TryExecutor
        Throws:
        java.util.concurrent.RejectedExecutionException

      • tryExecute

        public boolean tryExecute​(java.lang.Runnable task)

        Executes the given task if and only if a reserved thread is available.

        Specified by:
        tryExecute in interface TryExecutor
        Parameters:
        task - the task to run
        Returns:
        true if and only if a reserved thread was available and has been assigned the task to run.

      • startReservedThread

        private void startReservedThread()

      • dump

        public void dump​(java.lang.Appendable out,
                 java.lang.String indent)
          throws java.io.IOException
        Description copied from interface: Dumpable
        Dump this object (and children) into an Appendable using the provided indent after any new lines. The indent should not be applied to the first object dumped.
        Specified by:
        dump in interface Dumpable
        Parameters:
        out - The appendable to dump to
        indent - The indent to apply after any new lines.
        Throws:
        java.io.IOException - if unable to write to Appendable