org.eclipse.jetty.util.thread

Class QueuedThreadPool

java.lang.Object

org.eclipse.jetty.util.component.AbstractLifeCycle

org.eclipse.jetty.util.component.ContainerLifeCycle

org.eclipse.jetty.util.thread.QueuedThreadPool

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ThreadFactory, Container, Destroyable, Dumpable, Dumpable.DumpableContainer, LifeCycle, ThreadPool, ThreadPool.SizedThreadPool, TryExecutor

Direct Known Subclasses:

MonitoredQueuedThreadPool

@ManagedObject(value="A thread pool")
public class QueuedThreadPool
extends ContainerLifeCycle
implements java.util.concurrent.ThreadFactory, ThreadPool.SizedThreadPool, Dumpable, TryExecutor

A thread pool with a queue of jobs to execute.

Jetty components that need threads (such as network acceptors and selector) may lease threads from this thread pool using a ThreadPoolBudget; these threads are "active" from the point of view of the thread pool, but not available to run transient jobs such as processing an HTTP request or a WebSocket frame.

QueuedThreadPool has a ReservedThreadExecutor which leases threads from this pool, but makes them available as if they are "idle" threads.

QueuedThreadPool therefore has the following fundamental values:

• threads: the current number of threads. These threads may execute a job (either internal or transient), or may be ready to run (either idle or reserved). This number may grow or shrink as the thread pool grows or shrinks.
• readyThreads: the current number of threads that are ready to run transient jobs. This number may grow or shrink as the thread pool grows or shrinks.
• leasedThreads: the number of threads that run internal jobs. This number is typically constant after this thread pool is started.

Given the definitions above, the most interesting definitions are:

• threads = readyThreads + leasedThreads + utilizedThreads
• readyThreads = idleThreads + availableReservedThreads
• maxAvailableThreads = maxThreads - leasedThreads
• utilizationRate = utilizedThreads / maxAvailableThreads

Other definitions, typically less interesting because they take into account threads that execute internal jobs, or because they don't take into account available reserved threads (that are essentially ready to execute transient jobs), are:

• busyThreads = utilizedThreads + leasedThreads
• getIdleThreads() idleThreads} = readyThreads - availableReservedThreads

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.Dumpable

Dumpable.DumpableContainer

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.thread.TryExecutor

TryExecutor.NoTryExecutor

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Container

Container.InheritedListener, Container.Listener

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

FAILED, RUNNING, STARTED, STARTING, STOPPED, STOPPING

Fields inherited from interface org.eclipse.jetty.util.component.Dumpable

KEY

Fields inherited from interface org.eclipse.jetty.util.thread.TryExecutor

NO_TRY

Constructor Summary

Constructors

Constructor and Description
QueuedThreadPool()
QueuedThreadPool(int maxThreads)
QueuedThreadPool(int maxThreads, int minThreads)
QueuedThreadPool(int maxThreads, int minThreads, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue)
QueuedThreadPool(int maxThreads, int minThreads, int idleTimeout)
QueuedThreadPool(int maxThreads, int minThreads, int idleTimeout, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue)
QueuedThreadPool(int maxThreads, int minThreads, int idleTimeout, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue, java.lang.ThreadGroup threadGroup)
QueuedThreadPool(int maxThreads, int minThreads, int idleTimeout, int reservedThreads, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue, java.lang.ThreadGroup threadGroup)
QueuedThreadPool(int maxThreads, int minThreads, int idleTimeout, int reservedThreads, java.util.concurrent.BlockingQueue<java.lang.Runnable> queue, java.lang.ThreadGroup threadGroup, java.util.concurrent.ThreadFactory threadFactory)

Method Summary

Modifier and Type	Method and Description
protected void	doStart() Starts the managed lifecycle beans in the order they were added.
protected void	doStop() Stops the managed lifecycle beans in the reverse order they were added.
void	dump(java.lang.Appendable out, java.lang.String indent) Dump this object (and children) into an Appendable using the provided indent after any new lines.
java.lang.String	dumpThread(long id)
void	execute(java.lang.Runnable job)
int	getAvailableReservedThreads()
int	getBusyThreads() The number of threads executing internal and transient jobs.
int	getIdleThreads() The number of idle threads, but without including reserved threads.
int	getIdleTimeout()
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.
int	getLowThreadsThreshold()
int	getMaxAvailableThreads() The maximum number of threads available to run transient jobs.
int	getMaxLeasedThreads() The maximum number of threads that are leased to internal components, as some component may allocate its threads lazily.
int	getMaxReservedThreads()
int	getMaxThreads()
int	getMinThreads()
java.lang.String	getName()
protected java.util.concurrent.BlockingQueue<java.lang.Runnable>	getQueue()
int	getQueueSize()
int	getReadyThreads() The fundamental value that represents the number of threads ready to execute transient jobs.
int	getReservedThreads()
ThreadPoolBudget	getThreadPoolBudget()
int	getThreads() The fundamental value that represents the number of threads currently known by this thread pool.
int	getThreadsPriority()
double	getUtilizationRate() The rate between the number of utilized threads and the maximum number of utilizable threads.
int	getUtilizedThreads() The number of threads executing transient jobs.
boolean	interruptThread(long id)
boolean	isDaemon()
boolean	isDetailedDump()
boolean	isLowOnThreads() Returns whether this thread pool is low on threads.
void	join() Blocks until the thread pool is stopped.
java.lang.Thread	newThread(java.lang.Runnable runnable)
protected void	removeThread(java.lang.Thread thread)
protected void	runJob(java.lang.Runnable job) Runs the given job in the current thread.
void	setDaemon(boolean daemon)
void	setDetailedDump(boolean detailedDump)
void	setIdleTimeout(int idleTimeout) Set the maximum thread idle time in ms.
void	setLowThreadsThreshold(int lowThreadsThreshold)
void	setMaxThreads(int maxThreads)
void	setMinThreads(int minThreads)
void	setName(java.lang.String name) Sets the name of this thread pool, used as a prefix for the thread names.
void	setQueue(java.util.concurrent.BlockingQueue<java.lang.Runnable> queue) Deprecated. pass the queue to the constructor instead
void	setReservedThreads(int reservedThreads)
void	setThreadPoolBudget(ThreadPoolBudget budget)
void	setThreadsPriority(int priority)
protected void	startThread()
java.lang.String	toString()
boolean	tryExecute(java.lang.Runnable task) Attempt to execute a task.

Methods inherited from class org.eclipse.jetty.util.component.ContainerLifeCycle

addBean, addBean, addEventListener, addManaged, contains, destroy, dump, dump, dump, dump, dumpBeans, dumpObject, dumpObjects, dumpStdErr, dumpThis, getBean, getBeans, getBeans, getContainedBeans, getContainedBeans, isAuto, isManaged, isUnmanaged, manage, removeBean, removeBeans, removeEventListener, setBeans, setStopTimeout, start, stop, unmanage, updateBean, updateBean, updateBeans

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

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

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.eclipse.jetty.util.component.Dumpable

dump, dump, dumpContainer, dumpIterable, dumpMapEntries, dumpObject, dumpObjects, dumpSelf, named

Methods inherited from interface org.eclipse.jetty.util.thread.TryExecutor

asTryExecutor

Methods inherited from interface org.eclipse.jetty.util.component.Dumpable.DumpableContainer

isDumpable

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

start, stop

Constructor Detail

QueuedThreadPool

public QueuedThreadPool()

QueuedThreadPool

public QueuedThreadPool(@Name(value="maxThreads")
                        int maxThreads)

QueuedThreadPool

public QueuedThreadPool(@Name(value="maxThreads")
                        int maxThreads,
                        @Name(value="minThreads")
                        int minThreads)

QueuedThreadPool

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

QueuedThreadPool

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

QueuedThreadPool

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

QueuedThreadPool

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

QueuedThreadPool

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

QueuedThreadPool

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

Method Detail

getThreadPoolBudget

public ThreadPoolBudget getThreadPoolBudget()

Specified by:

getThreadPoolBudget in interface ThreadPool.SizedThreadPool

Returns:

a ThreadPoolBudget for this sized thread pool, or null of no ThreadPoolBudget can be returned

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

getIdleTimeout

@ManagedAttribute(value="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

getMaxThreads

@ManagedAttribute(value="maximum number of threads in the pool")
public int getMaxThreads()

Specified by:

getMaxThreads in interface ThreadPool.SizedThreadPool

Returns:

the maximum number of threads

setMaxThreads

public void setMaxThreads(int maxThreads)

Specified by:

setMaxThreads in interface ThreadPool.SizedThreadPool

Parameters:

maxThreads - the maximum number of threads

getMinThreads

@ManagedAttribute(value="minimum number of threads in the pool")
public int getMinThreads()

Specified by:

getMinThreads in interface ThreadPool.SizedThreadPool

Returns:

the minimum number of threads

setMinThreads

public void setMinThreads(int minThreads)

Specified by:

setMinThreads in interface ThreadPool.SizedThreadPool

Parameters:

minThreads - minimum number of threads

getReservedThreads

@ManagedAttribute(value="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(value="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(value="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(value="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(value="reports additional details in the dump")
public boolean isDetailedDump()

setDetailedDump

public void setDetailedDump(boolean detailedDump)

getLowThreadsThreshold

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

setLowThreadsThreshold

public void setLowThreadsThreshold(int lowThreadsThreshold)

getQueueSize

@ManagedAttribute(value="size of the job queue")
public int getQueueSize()

Returns:

the number of jobs in the queue waiting for a thread

getMaxReservedThreads

@ManagedAttribute(value="maximum number (capacity) of reserved threads")
public int getMaxReservedThreads()

Returns:

the maximum number (capacity) of reserved threads

See Also:

ReservedThreadExecutor.getCapacity()

getAvailableReservedThreads

@ManagedAttribute(value="number of available reserved threads")
public int getAvailableReservedThreads()

Returns:

the number of available reserved threads

See Also:

ReservedThreadExecutor.getAvailable()

getThreads

@ManagedAttribute(value="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(value="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(value="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(value="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(value="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(value="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(value="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(value="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(value="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

startThread

protected void startThread()

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

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(value="interrupts a pool thread")
public boolean interruptThread(@Name(value="id")
                                                                                   long id)

Parameters:

id - the thread ID to interrupt.

Returns:

true if the thread was found and interrupted.

dumpThread

@ManagedOperation(value="dumps a pool thread stack")
public java.lang.String dumpThread(@Name(value="id")
                                                                                        long id)

Parameters:

id - the thread ID to interrupt.

Returns:

the stack frames dump

toString

public java.lang.String toString()

Overrides:

toString in class AbstractLifeCycle