QueuelessExecutor

java.lang.Object
- java.util.concurrent.AbstractExecutorService
- - org.jboss.threads.QueuelessExecutor

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService, BlockingExecutor, BlockingExecutorService, BoundedThreadPoolExecutorMBean, ThreadExecutorMBean, ThreadPoolExecutorMBean, ShutdownListenable
```
public final class QueuelessExecutor
extends java.util.concurrent.AbstractExecutorService
implements BlockingExecutorService, BoundedThreadPoolExecutorMBean, ShutdownListenable
```
A queueless thread pool. If one or more threads are waiting for work when a task is submitted, it will be used. Otherwise, if fewer than the maximum threads are started, a new thread is created.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class QueuelessExecutor.Worker

Nested Classes
Modifier and Type	Class and Description
`private class`	`QueuelessExecutor.Worker`

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`blocking` Specify whether this executor blocks when no threads are available.
`private java.util.concurrent.Executor`	`handoffExecutor`
`private long`	`keepAliveTime` Configuration value.
`private int`	`largestPoolSize`
`private java.util.concurrent.locks.Lock`	`lock`
`private static org.jboss.logging.Logger`	`log`
`private int`	`maxThreads` Configuration value.
`private java.util.concurrent.locks.Condition`	`nextReady`
`private int`	`rejectedCount`
`private java.util.concurrent.locks.Condition`	`runnableDequeued`
`private java.util.Set<java.lang.Thread>`	`runningThreads` Protected by `lock`
`private SimpleShutdownListenable`	`shutdownListenable`
`private boolean`	`stop`
`private java.util.concurrent.locks.Condition`	`taskEnqueued`
`private DirectExecutor`	`taskExecutor`
`private java.util.concurrent.locks.Condition`	`threadDeath`
`private java.util.concurrent.ThreadFactory`	`threadFactory`
`private QueuelessExecutor.Worker`	`waitingWorker` Protected by `lock`, signal `workerDequeued` on clear
`private java.util.concurrent.locks.Condition`	`workerDequeued`
`private java.lang.Runnable`	`workRunnable` Protected by `lock`, signal `runnableDequeued` on clear

Constructor Summary

Constructors
Constructor and Description
`QueuelessExecutor(java.util.concurrent.ThreadFactory threadFactory, DirectExecutor taskExecutor, java.util.concurrent.Executor handoffExecutor, long keepAliveTime)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<A> void`	`addShutdownListener(EventListener<A> shutdownListener, A attachment)` Add a shutdown listener.
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`private static long`	`clipHigh(long value)`
`void`	`execute(java.lang.Runnable task)` Executes the given command at some time in the future.
`void`	`executeBlocking(java.lang.Runnable task)` Execute a task, blocking until it can be accepted, or until the calling thread is interrupted.
`void`	`executeBlocking(java.lang.Runnable task, long timeout, java.util.concurrent.TimeUnit unit)` Execute a task, blocking until it can be accepted, a timeout elapses, or the calling thread is interrupted.
`void`	`executeNonBlocking(java.lang.Runnable task)` Execute a task, without blocking.
`int`	`getCurrentThreadCount()`
`java.util.concurrent.Executor`	`getHandoffExecutor()`
`long`	`getKeepAliveTime()`
`int`	`getLargestThreadCount()`
`int`	`getMaxThreads()`
`int`	`getQueueSize()`
`int`	`getRejectedCount()`
`boolean`	`isBlocking()`
`boolean`	`isShutdown()`
`boolean`	`isTerminated()`
`void`	`setBlocking(boolean blocking)`
`void`	`setHandoffExecutor(java.util.concurrent.Executor handoffExecutor)`
`void`	`setKeepAliveTime(long milliseconds)`
`void`	`setMaxThreads(int newSize)`
`void`	`shutdown()`
`java.util.List<java.lang.Runnable>`	`shutdownNow()`

Methods inherited from class java.util.concurrent.AbstractExecutorService
invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.concurrent.ExecutorService
invokeAll, invokeAll, invokeAny, invokeAny, submit, submit, submit

- Field Detail
  - log
```
private static final org.jboss.logging.Logger log
```
  - shutdownListenable
```
private final SimpleShutdownListenable shutdownListenable
```
  - threadFactory
```
private final java.util.concurrent.ThreadFactory threadFactory
```
  - taskExecutor
```
private final DirectExecutor taskExecutor
```
  - lock
```
private final java.util.concurrent.locks.Lock lock
```
  - runnableDequeued
```
private final java.util.concurrent.locks.Condition runnableDequeued
```
  - nextReady
```
private final java.util.concurrent.locks.Condition nextReady
```
  - workerDequeued
```
private final java.util.concurrent.locks.Condition workerDequeued
```
  - taskEnqueued
```
private final java.util.concurrent.locks.Condition taskEnqueued
```
  - threadDeath
```
private final java.util.concurrent.locks.Condition threadDeath
```
  - runningThreads
```
private final java.util.Set<java.lang.Thread> runningThreads
```
    Protected by lock
  - workRunnable
```
private java.lang.Runnable workRunnable
```
    Protected by lock, signal runnableDequeued on clear
  - waitingWorker
```
private QueuelessExecutor.Worker waitingWorker
```
    Protected by lock, signal workerDequeued on clear
  - keepAliveTime
```
private long keepAliveTime
```
    Configuration value. Protected by lock
  - maxThreads
```
private int maxThreads
```
    Configuration value. Protected by lock
  - blocking
```
private boolean blocking
```
    Specify whether this executor blocks when no threads are available. Protected by lock
  - handoffExecutor
```
private java.util.concurrent.Executor handoffExecutor
```
  - stop
```
private boolean stop
```
  - largestPoolSize
```
private int largestPoolSize
```
  - rejectedCount
```
private int rejectedCount
```
- Constructor Detail
  - QueuelessExecutor
```
public QueuelessExecutor(java.util.concurrent.ThreadFactory threadFactory,
                         DirectExecutor taskExecutor,
                         java.util.concurrent.Executor handoffExecutor,
                         long keepAliveTime)
```
- Method Detail
  - getMaxThreads
```
public int getMaxThreads()
```
    Specified by:
    
    getMaxThreads in interface ThreadPoolExecutorMBean
  - setMaxThreads
```
public void setMaxThreads(int newSize)
```
    Specified by:
    
    setMaxThreads in interface ThreadPoolExecutorMBean
  - getKeepAliveTime
```
public long getKeepAliveTime()
```
    Specified by:
    
    getKeepAliveTime in interface ThreadPoolExecutorMBean
  - setKeepAliveTime
```
public void setKeepAliveTime(long milliseconds)
```
    Specified by:
    
    setKeepAliveTime in interface ThreadPoolExecutorMBean
  - getCurrentThreadCount
```
public int getCurrentThreadCount()
```
    Specified by:
    
    getCurrentThreadCount in interface ThreadExecutorMBean
  - getLargestThreadCount
```
public int getLargestThreadCount()
```
    Specified by:
    
    getLargestThreadCount in interface ThreadExecutorMBean
  - getRejectedCount
```
public int getRejectedCount()
```
    Specified by:
    
    getRejectedCount in interface ThreadExecutorMBean
  - getQueueSize
```
public int getQueueSize()
```
    Specified by:
    
    getQueueSize in interface ThreadExecutorMBean
  - isBlocking
```
public boolean isBlocking()
```
    Specified by:
    
    isBlocking in interface BoundedThreadPoolExecutorMBean
  - setBlocking
```
public void setBlocking(boolean blocking)
```
    Specified by:
    
    setBlocking in interface BoundedThreadPoolExecutorMBean
  - getHandoffExecutor
```
public java.util.concurrent.Executor getHandoffExecutor()
```
  - setHandoffExecutor
```
public void setHandoffExecutor(java.util.concurrent.Executor handoffExecutor)
```
  - shutdown
```
public void shutdown()
```
    Specified by:
    
    shutdown in interface java.util.concurrent.ExecutorService
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
```
    Specified by:
    
    awaitTermination in interface java.util.concurrent.ExecutorService
    
    Throws:
    
    java.lang.InterruptedException
  - shutdownNow
```
public java.util.List<java.lang.Runnable> shutdownNow()
```
    Specified by:
    
    shutdownNow in interface java.util.concurrent.ExecutorService
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
  - execute
```
public void execute(java.lang.Runnable task)
```
    Description copied from interface: BlockingExecutor
    
    Executes the given command at some time in the future. The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the Executor implementation. The call may block or not block, depending on the configuration of the executor.
    
    Specified by:
    
    execute in interface java.util.concurrent.Executor
    
    Specified by:
    
    execute in interface BlockingExecutor
    
    Parameters:
    
    task - the task to submit
  - executeBlocking
```
public void executeBlocking(java.lang.Runnable task)
                     throws java.util.concurrent.RejectedExecutionException,
                            java.lang.InterruptedException
```
    Description copied from interface: BlockingExecutor
    
    Execute a task, blocking until it can be accepted, or until the calling thread is interrupted.
    
    Specified by:
    
    executeBlocking in interface BlockingExecutor
    
    Parameters:
    
    task - the task to submit
    
    Throws:
    
    StoppedExecutorException - if the executor was shut down before the task was accepted
    
    ThreadCreationException - if a thread could not be created for some reason
    
    java.util.concurrent.RejectedExecutionException - if execution is rejected for some other reason
    
    java.lang.InterruptedException - if the current thread was interrupted before the task could be accepted
  - executeBlocking
```
public void executeBlocking(java.lang.Runnable task,
                            long timeout,
                            java.util.concurrent.TimeUnit unit)
                     throws java.util.concurrent.RejectedExecutionException,
                            java.lang.InterruptedException
```
    Description copied from interface: BlockingExecutor
    
    Execute a task, blocking until it can be accepted, a timeout elapses, or the calling thread is interrupted.
    
    Specified by:
    
    executeBlocking in interface BlockingExecutor
    
    Parameters:
    
    task - the task to submit
    
    timeout - the amount of time to wait
    
    unit - the unit of time
    
    Throws:
    
    ExecutionTimedOutException - if the timeout elapsed before a task could be accepted
    
    StoppedExecutorException - if the executor was shut down before the task was accepted
    
    ThreadCreationException - if a thread could not be created for some reason
    
    java.util.concurrent.RejectedExecutionException - if execution is rejected for some other reason
    
    java.lang.InterruptedException - if the current thread was interrupted before the task could be accepted
  - executeNonBlocking
```
public void executeNonBlocking(java.lang.Runnable task)
                        throws java.util.concurrent.RejectedExecutionException
```
    Description copied from interface: BlockingExecutor
    
    Execute a task, without blocking.
    
    Specified by:
    
    executeNonBlocking in interface BlockingExecutor
    
    Parameters:
    
    task - the task to submit
    
    Throws:
    
    StoppedExecutorException - if the executor was shut down before the task was accepted
    
    ThreadCreationException - if a thread could not be created for some reason
    
    java.util.concurrent.RejectedExecutionException - if execution is rejected for some other reason
  - addShutdownListener
```
public <A> void addShutdownListener(EventListener<A> shutdownListener,
                                    A attachment)
```
    Add a shutdown listener. If the target object is already shut down, the listener is invoked directly.
    
    Specified by:
    
    addShutdownListener in interface ShutdownListenable
    
    Type Parameters:
    
    A - the attachment type
    
    Parameters:
    
    shutdownListener - the listener
    
    attachment - the attachment value to pass to the listener
  - clipHigh
```
private static long clipHigh(long value)
```

Class QueuelessExecutor

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.util.concurrent.AbstractExecutorService

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.concurrent.ExecutorService

Field Detail

log

shutdownListenable

threadFactory

taskExecutor

lock

runnableDequeued

nextReady

workerDequeued

taskEnqueued

threadDeath

runningThreads

workRunnable

waitingWorker

keepAliveTime

maxThreads

blocking

handoffExecutor

stop

largestPoolSize

rejectedCount

Constructor Detail

QueuelessExecutor

Method Detail

getMaxThreads

setMaxThreads

getKeepAliveTime

setKeepAliveTime

getCurrentThreadCount

getLargestThreadCount

getRejectedCount

getQueueSize

isBlocking

setBlocking

getHandoffExecutor

setHandoffExecutor

shutdown

awaitTermination

shutdownNow

isShutdown

isTerminated

execute

executeBlocking

executeBlocking

executeNonBlocking

addShutdownListener

clipHigh