Package org.eclipse.jetty.util.thread

Class QueuedThreadPool

    • Field Detail

      • LOG

        private static final Logger LOG

      • NOOP

        private static final java.lang.Runnable NOOP

      • _counts

        private final AtomicBiInteger _counts
        Encodes thread counts:
        Hi
        Total thread count or Integer.MIN_VALUE if the pool is stopping
        Lo
        Net idle threads == idle threads - job queue size. Essentially if positive, this represents the effective number of idle threads, and if negative it represents the demand for more threads

      • _lastShrink

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

      • _threads

        private final java.util.Set<java.lang.Thread> _threads

      • _joinLock

        private final java.lang.Object _joinLock

      • _jobs

        private final java.util.concurrent.BlockingQueue<java.lang.Runnable> _jobs

      • _threadGroup

        private final java.lang.ThreadGroup _threadGroup

      • _threadFactory

        private final java.util.concurrent.ThreadFactory _threadFactory

      • _name

        private java.lang.String _name

      • _idleTimeout

        private int _idleTimeout

      • _maxThreads

        private int _maxThreads

      • _minThreads

        private int _minThreads

      • _reservedThreads

        private int _reservedThreads

      • _priority

        private int _priority

      • _daemon

        private boolean _daemon

      • _detailedDump

        private boolean _detailedDump

      • _lowThreadsThreshold

        private int _lowThreadsThreshold

      • _runnable

        private final java.lang.Runnable _runnable

    • Constructor Detail

      • QueuedThreadPool

        public QueuedThreadPool()

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads,
                        @Name("queue")
                        java.util.concurrent.BlockingQueue<java.lang.Runnable> queue)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads,
                        @Name("idleTimeout")
                        int idleTimeout)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads,
                        @Name("idleTimeout")
                        int idleTimeout,
                        @Name("queue")
                        java.util.concurrent.BlockingQueue<java.lang.Runnable> queue)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads,
                        @Name("idleTimeout")
                        int idleTimeout,
                        @Name("queue")
                        java.util.concurrent.BlockingQueue<java.lang.Runnable> queue,
                        @Name("threadGroup")
                        java.lang.ThreadGroup threadGroup)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads,
                        @Name("idleTimeout")
                        int idleTimeout,
                        @Name("reservedThreads")
                        int reservedThreads,
                        @Name("queue")
                        java.util.concurrent.BlockingQueue<java.lang.Runnable> queue,
                        @Name("threadGroup")
                        java.lang.ThreadGroup threadGroup)

      • QueuedThreadPool

        public QueuedThreadPool​(@Name("maxThreads")
                        int maxThreads,
                        @Name("minThreads")
                        int minThreads,
                        @Name("idleTimeout")
                        int idleTimeout,
                        @Name("reservedThreads")
                        int reservedThreads,
                        @Name("queue")
                        java.util.concurrent.BlockingQueue<java.lang.Runnable> queue,
                        @Name("threadGroup")
                        java.lang.ThreadGroup threadGroup,
                        @Name("threadFactory")
                        java.util.concurrent.ThreadFactory threadFactory)

    • Method Detail

      • setThreadPoolBudget

        public void setThreadPoolBudget​(ThreadPoolBudget budget)

      • doStart

        protected void doStart()
                throws java.lang.Exception
        Description copied from class: ContainerLifeCycle
        Starts the managed lifecycle beans in the order they were added.
        Overrides:
        doStart in class ContainerLifeCycle
        Throws:
        java.lang.Exception

      • doStop

        protected void doStop()
               throws java.lang.Exception
        Description copied from class: ContainerLifeCycle
        Stops the managed lifecycle beans in the reverse order they were added.
        Overrides:
        doStop in class ContainerLifeCycle
        Throws:
        java.lang.Exception

      • joinThreads

        private void joinThreads​(long stopByNanos)
                  throws java.lang.InterruptedException
        Throws:
        java.lang.InterruptedException

      • getIdleTimeout

        @ManagedAttribute("maximum time a thread may be idle in ms")
public int getIdleTimeout()
        Returns:
        the maximum thread idle time in ms

      • setIdleTimeout

        public void setIdleTimeout​(int idleTimeout)

        Set the maximum thread idle time in ms.

        Threads that are idle for longer than this period may be stopped.

        Parameters:
        idleTimeout - the maximum thread idle time in ms

      • getReservedThreads

        @ManagedAttribute("number of configured reserved threads or -1 for heuristic")
public int getReservedThreads()
        Returns:
        number of reserved threads or -1 for heuristically determined

      • setReservedThreads

        public void setReservedThreads​(int reservedThreads)
        Parameters:
        reservedThreads - number of reserved threads or -1 for heuristically determined

      • getName

        @ManagedAttribute("name of the thread pool")
public java.lang.String getName()
        Returns:
        the name of the this thread pool

      • setName

        public void setName​(java.lang.String name)

        Sets the name of this thread pool, used as a prefix for the thread names.

        Parameters:
        name - the name of the this thread pool

      • getThreadsPriority

        @ManagedAttribute("priority of threads in the pool")
public int getThreadsPriority()
        Returns:
        the priority of the pool threads

      • setThreadsPriority

        public void setThreadsPriority​(int priority)
        Parameters:
        priority - the priority of the pool threads

      • isDaemon

        @ManagedAttribute("thread pool uses daemon threads")
public boolean isDaemon()
        Returns:
        whether to use daemon threads
        See Also:
        Thread.isDaemon()

      • setDaemon

        public void setDaemon​(boolean daemon)
        Parameters:
        daemon - whether to use daemon threads
        See Also:
        Thread.setDaemon(boolean)

      • isDetailedDump

        @ManagedAttribute("reports additional details in the dump")
public boolean isDetailedDump()

      • setDetailedDump

        public void setDetailedDump​(boolean detailedDump)

      • getLowThreadsThreshold

        @ManagedAttribute("threshold at which the pool is low on threads")
public int getLowThreadsThreshold()

      • setLowThreadsThreshold

        public void setLowThreadsThreshold​(int lowThreadsThreshold)

      • getQueueSize

        @ManagedAttribute("size of the job queue")
public int getQueueSize()
        Returns:
        the number of jobs in the queue waiting for a thread

      • getThreads

        @ManagedAttribute("number of threads in the pool")
public int getThreads()

        The fundamental value that represents the number of threads currently known by this thread pool.

        This value includes threads that have been leased to internal components, idle threads, reserved threads and threads that are executing transient jobs.

        Specified by:
        getThreads in interface ThreadPool
        Returns:
        the number of threads currently known to the pool
        See Also:
        getReadyThreads(), getLeasedThreads()

      • getReadyThreads

        @ManagedAttribute("number of threads ready to execute transient jobs")
public int getReadyThreads()

        The fundamental value that represents the number of threads ready to execute transient jobs.

        Returns:
        the number of threads ready to execute transient jobs
        See Also:
        getThreads(), getLeasedThreads(), getUtilizedThreads()

      • getLeasedThreads

        @ManagedAttribute("number of threads used by internal components")
public int getLeasedThreads()

        The fundamental value that represents the number of threads that are leased to internal components, and therefore cannot be used to execute transient jobs.

        Returns:
        the number of threads currently used by internal components
        See Also:
        getThreads(), getReadyThreads()

      • getMaxLeasedThreads

        @ManagedAttribute("maximum number of threads leased to internal components")
public int getMaxLeasedThreads()

        The maximum number of threads that are leased to internal components, as some component may allocate its threads lazily.

        Returns:
        the maximum number of threads leased by internal components
        See Also:
        getLeasedThreads()

      • getIdleThreads

        @ManagedAttribute("number of idle threads but not reserved")
public int getIdleThreads()

        The number of idle threads, but without including reserved threads.

        Prefer getReadyThreads() for a better representation of "threads ready to execute transient jobs".

        Specified by:
        getIdleThreads in interface ThreadPool
        Returns:
        the number of idle threads but not reserved
        See Also:
        getReadyThreads()

      • getBusyThreads

        @ManagedAttribute("number of threads executing internal and transient jobs")
public int getBusyThreads()

        The number of threads executing internal and transient jobs.

        Prefer getUtilizedThreads() for a better representation of "threads executing transient jobs".

        Returns:
        the number of threads executing internal and transient jobs
        See Also:
        getUtilizedThreads()

      • getUtilizedThreads

        @ManagedAttribute("number of threads executing transient jobs")
public int getUtilizedThreads()

        The number of threads executing transient jobs.

        Returns:
        the number of threads executing transient jobs
        See Also:
        getReadyThreads()

      • getMaxAvailableThreads

        @ManagedAttribute("maximum number of threads available to run transient jobs")
public int getMaxAvailableThreads()

        The maximum number of threads available to run transient jobs.

        Returns:
        the maximum number of threads available to run transient jobs

      • getUtilizationRate

        @ManagedAttribute("utilization rate of threads executing transient jobs")
public double getUtilizationRate()

        The rate between the number of utilized threads and the maximum number of utilizable threads.

        A value of 0.0D means that the thread pool is not utilized, while a value of 1.0D means that the thread pool is fully utilized to execute transient jobs.

        Returns:
        the utilization rate of threads executing transient jobs

      • isLowOnThreads

        @ManagedAttribute(value="thread pool is low on threads",
                  readonly=true)
public boolean isLowOnThreads()

        Returns whether this thread pool is low on threads.

        The current formula is:

         maxThreads - threads + readyThreads - queueSize <= lowThreadsThreshold
        Specified by:
        isLowOnThreads in interface ThreadPool
        Returns:
        whether the pool is low on threads
        See Also:
        getLowThreadsThreshold()

      • execute

        public void execute​(java.lang.Runnable job)
        Specified by:
        execute in interface java.util.concurrent.Executor
        Specified by:
        execute in interface TryExecutor

      • tryExecute

        public boolean tryExecute​(java.lang.Runnable task)
        Description copied from interface: TryExecutor
        Attempt to execute a task.
        Specified by:
        tryExecute in interface TryExecutor
        Parameters:
        task - The task to be executed
        Returns:
        True IFF the task has been given directly to a thread to execute. The task cannot be queued pending the later availability of a Thread.

      • join

        public void join()
          throws java.lang.InterruptedException
        Blocks until the thread pool is stopped.
        Specified by:
        join in interface ThreadPool
        Throws:
        java.lang.InterruptedException - if thread was interrupted

      • ensureThreads

        private void ensureThreads()

      • startThread

        protected void startThread()

      • addCounts

        private boolean addCounts​(int deltaThreads,
                          int deltaIdle)

      • newThread

        public java.lang.Thread newThread​(java.lang.Runnable runnable)
        Specified by:
        newThread in interface java.util.concurrent.ThreadFactory

      • removeThread

        protected void removeThread​(java.lang.Thread thread)

      • 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
        Overrides:
        dump in class ContainerLifeCycle
        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

      • getCompressedStackTag

        private java.lang.String getCompressedStackTag​(java.lang.StackTraceElement[] trace)

      • runJob

        protected void runJob​(java.lang.Runnable job)

        Runs the given job in the current thread.

        Subclasses may override to perform pre/post actions before/after the job is run.

        Parameters:
        job - the job to run

      • getQueue

        protected java.util.concurrent.BlockingQueue<java.lang.Runnable> getQueue()
        Returns:
        the job queue

      • setQueue

        @Deprecated
public void setQueue​(java.util.concurrent.BlockingQueue<java.lang.Runnable> queue)
        Deprecated.
        pass the queue to the constructor instead
        Parameters:
        queue - the job queue

      • interruptThread

        @ManagedOperation("interrupts a pool thread")
public boolean interruptThread​(@Name("id")
                               long id)
        Parameters:
        id - the thread ID to interrupt.
        Returns:
        true if the thread was found and interrupted.

      • dumpThread

        @ManagedOperation("dumps a pool thread stack")
public java.lang.String dumpThread​(@Name("id")
                                   long id)
        Parameters:
        id - the thread ID to interrupt.
        Returns:
        the stack frames dump