DispatchQueue

java.lang.Object
- xal.tools.dispatch.DispatchQueue

```
public abstract class DispatchQueue
extends java.lang.Object
```
DispatchQueue which attempts to implement a subset of the open source libdispatch library

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class DispatchQueue.DispatchQueueState
possible states of the dispatch queue

Nested Classes
Modifier and Type	Class and Description
`static class`	`DispatchQueue.DispatchQueueState` possible states of the dispatch queue

Field Summary

Fields
Modifier and Type	Field and Description
`protected DispatchQueue.DispatchQueueState`	`_queueState` state of this queue
`protected java.util.concurrent.ExecutorService`	`DISPATCH_EXECUTOR` executor for processing dispatched operations
`static int`	`DISPATCH_QUEUE_PRIORITY_BACKGROUND` priority for the background priority queue
`static int`	`DISPATCH_QUEUE_PRIORITY_DEFAULT` priority for the default priority queue
`static int`	`DISPATCH_QUEUE_PRIORITY_HIGH` priority for a high priority queue
`static int`	`DISPATCH_QUEUE_PRIORITY_LOW` priority for the low priority queue
`protected java.util.concurrent.ThreadFactory`	`DISPATCH_THREAD_FACTORY` thread factory for dispatch this queue
`protected java.util.concurrent.LinkedBlockingQueue<xal.tools.dispatch.DispatchOperation<?>>`	`PENDING_OPERATION_QUEUE` queue of pending operations which have not yet been submitted for execution
`protected java.util.concurrent.ExecutorService`	`QUEUE_PROCESSOR` executor which processes the queue
`protected java.util.concurrent.atomic.AtomicInteger`	`RUNNING_OPERATION_COUNTER` number of operations currently running

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`DispatchQueue(java.lang.String label)` Constructor
`protected`	`DispatchQueue(java.lang.String label, int priority)` Primary Constructor

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`static DispatchQueue`	`createConcurrentQueue(java.lang.String label)` Create a concurrent queue
`protected abstract java.util.concurrent.ExecutorService`	`createDispatchExecutor()` create the executor for dispatching operations
`static DispatchQueue`	`createSerialQueue(java.lang.String label)` Create a serial queue
`protected int`	`decrementRunningOperationCount()` decrement the running operations count
`void`	`dispatchAfter(java.util.Date dispatchTime, java.lang.Runnable rawOperation)` dispatch the operation after the specified time without blocking
`void`	`dispatchApply(int iterations, DispatchIterationKernel iterationKernel)` Performs all the specified iterations of the kernel asynchronously and waits for them to complete.
`void`	`dispatchAsync(DispatchGroup group, java.lang.Runnable rawOperation)` submit the operation for execution on the queue and add it to the specified group without waiting for completion
`protected void`	`dispatchAsync(DispatchGroup group, java.lang.Runnable rawOperation, boolean isBarrier)` submit the operation for execution on the queue and add it to the specified group without waiting for completion
`void`	`dispatchAsync(java.lang.Runnable rawOperation)` submit the operation for execution on the queue without waiting for completion
`void`	`dispatchBarrierAsync(java.lang.Runnable operation)` Submit a barrier block for execution on the queue without waiting for completion.
`void`	`dispatchBarrierSync(java.lang.Runnable operation)` Submit a barrier block for execution on the queue and wait for completion.
`<ReturnType> ReturnType`	`dispatchSync(java.util.concurrent.Callable<ReturnType> rawOperation)` submit the operation for execution on the queue and wait for it to complete
`void`	`dispatchSync(java.lang.Runnable rawOperation)` submit the operation for execution on the queue and wait for it to complete
`protected void`	`dispatchSync(java.lang.Runnable rawOperation, boolean isBarrier)` submit the operation for execution on the queue and wait for it to complete
`void`	`dispose()` dispose of this queue - can only be called on a custom queue
`protected <ReturnType> void`	`enqueueOperation(xal.tools.dispatch.DispatchOperation<ReturnType> operation)` Enqueue the operation and process make sure the operation queue gets processed
`protected void`	`finalize()` dispose of the executors
`static DispatchQueue`	`getCurrentQueue()` get the current queue or null if the current thread does not belong to a queue
`static DispatchQueue`	`getGlobalBackgroundPriorityQueue()` Get the global background priority queue
`static DispatchQueue`	`getGlobalDefaultPriorityQueue()` Get the global default priority queue
`static DispatchQueue`	`getGlobalHighPriorityQueue()` Get the global high priority queue
`static DispatchQueue`	`getGlobalLowPriorityQueue()` Get the global low priority queue
`static DispatchQueue`	`getGlobalQueue(int priority)` Get the global queue corresponding to the specified priority.
`java.lang.String`	`getLabel()` get this queue's label
`static DispatchQueue`	`getMainQueue()` Get the main queue on which Swing events are dispatched.
`protected int`	`incrementRunningOperationCount()` increment the running operations count
`boolean`	`isCurrentQueue()` Determine whether this queue is the current queue
`boolean`	`isDisposed()` determine whether this queue has been disposed
`boolean`	`isSuspended()` Determines whether this queue is suspended (disposed implies suspended)
`protected <ReturnType> xal.tools.dispatch.DispatchOperation<ReturnType>`	`makeDispatchOperation(java.util.concurrent.Callable<ReturnType> rawOperation)` Make a callable operation wrapper from a raw runnable operation
`protected <ReturnType> xal.tools.dispatch.DispatchOperation<ReturnType>`	`makeDispatchOperation(java.util.concurrent.Callable<ReturnType> rawOperation, boolean isBarrier)` Make a callable operation wrapper from a raw runnable operation
`protected xal.tools.dispatch.DispatchOperation<java.lang.Void>`	`makeDispatchOperation(java.lang.Runnable rawOperation)` Make a callable operation wrapper from a raw runnable operation
`protected xal.tools.dispatch.DispatchOperation<java.lang.Void>`	`makeDispatchOperation(java.lang.Runnable rawOperation, boolean isBarrier)` Make a callable operation wrapper from a raw runnable operation
`<ReturnType> void`	`operationCompleted(xal.tools.dispatch.DispatchOperation<ReturnType> operation)` Event indicating that an operation in this group has completed
`protected <ReturnType> void`	`postProcessOperation(xal.tools.dispatch.DispatchOperation<ReturnType> operation)` call this method when an operation has completed execution
`protected abstract void`	`processOperationQueue()` Process the operation queue by processing the next pending operation using the serial queue processor to guarantee the operations are queue serially
`protected void`	`releaseResources()` release allocated resources - called internally for any queue
`void`	`resume()` resume execution of pending operations if suspended or throw an exception if attempting to resume a disposed queue
`void`	`suspend()` suspend execution of pending operations if processing (nothing if disposed or already suspended)

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

- Field Detail
  - DISPATCH_QUEUE_PRIORITY_HIGH
```
public static final int DISPATCH_QUEUE_PRIORITY_HIGH
```
    priority for a high priority queue
  - DISPATCH_QUEUE_PRIORITY_DEFAULT
```
public static final int DISPATCH_QUEUE_PRIORITY_DEFAULT
```
    priority for the default priority queue
  - DISPATCH_QUEUE_PRIORITY_LOW
```
public static final int DISPATCH_QUEUE_PRIORITY_LOW
```
    priority for the low priority queue
  - DISPATCH_QUEUE_PRIORITY_BACKGROUND
```
public static final int DISPATCH_QUEUE_PRIORITY_BACKGROUND
```
    priority for the background priority queue
  - QUEUE_PROCESSOR
```
protected final java.util.concurrent.ExecutorService QUEUE_PROCESSOR
```
    executor which processes the queue
  - DISPATCH_THREAD_FACTORY
```
protected final java.util.concurrent.ThreadFactory DISPATCH_THREAD_FACTORY
```
    thread factory for dispatch this queue
  - DISPATCH_EXECUTOR
```
protected final java.util.concurrent.ExecutorService DISPATCH_EXECUTOR
```
    executor for processing dispatched operations
  - RUNNING_OPERATION_COUNTER
```
protected final java.util.concurrent.atomic.AtomicInteger RUNNING_OPERATION_COUNTER
```
    number of operations currently running
  - _queueState
```
protected volatile DispatchQueue.DispatchQueueState _queueState
```
    state of this queue
  - PENDING_OPERATION_QUEUE
```
protected final java.util.concurrent.LinkedBlockingQueue<xal.tools.dispatch.DispatchOperation<?>> PENDING_OPERATION_QUEUE
```
    queue of pending operations which have not yet been submitted for execution
- Constructor Detail
  - DispatchQueue
```
protected DispatchQueue(java.lang.String label,
                        int priority)
```
    Primary Constructor
  - DispatchQueue
```
protected DispatchQueue(java.lang.String label)
```
    Constructor
- Method Detail
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    dispose of the executors
    
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable
  - getLabel
```
public java.lang.String getLabel()
```
    get this queue's label
  - isSuspended
```
public boolean isSuspended()
```
    Determines whether this queue is suspended (disposed implies suspended)
  - suspend
```
public void suspend()
```
    suspend execution of pending operations if processing (nothing if disposed or already suspended)
  - resume
```
public void resume()
```
    resume execution of pending operations if suspended or throw an exception if attempting to resume a disposed queue
  - dispose
```
public void dispose()
```
    dispose of this queue - can only be called on a custom queue
  - isDisposed
```
public boolean isDisposed()
```
    determine whether this queue has been disposed
  - releaseResources
```
protected void releaseResources()
```
    release allocated resources - called internally for any queue
  - createDispatchExecutor
```
protected abstract java.util.concurrent.ExecutorService createDispatchExecutor()
```
    create the executor for dispatching operations
  - createConcurrentQueue
```
public static DispatchQueue createConcurrentQueue(java.lang.String label)
```
    Create a concurrent queue
    
    Parameters:
    
    label - optional label for the queue to create
    
    Returns:
    
    a new concurrent queue
  - createSerialQueue
```
public static DispatchQueue createSerialQueue(java.lang.String label)
```
    Create a serial queue
    
    Parameters:
    
    label - optional label for the queue to create
    
    Returns:
    
    a new serial queue
  - getMainQueue
```
public static DispatchQueue getMainQueue()
```
    Get the main queue on which Swing events are dispatched. The main queue cannot be suspended or resumed.
  - getGlobalQueue
```
public static DispatchQueue getGlobalQueue(int priority)
```
    Get the global queue corresponding to the specified priority. The global queue cannot be suspended or resumed.
    
    Parameters:
    
    priority - one of DISPATCH_QUEUE_PRIORITY_HIGH, DISPATCH_QUEUE_PRIORITY_DEFAULT, DISPATCH_QUEUE_PRIORITY_LOW, DISPATCH_QUEUE_PRIORITY_BACKGROUND
    
    Returns:
    
    the global queue corresponding to the specified priority or null if none exists.
  - getGlobalDefaultPriorityQueue
```
public static DispatchQueue getGlobalDefaultPriorityQueue()
```
    Get the global default priority queue
  - getGlobalHighPriorityQueue
```
public static DispatchQueue getGlobalHighPriorityQueue()
```
    Get the global high priority queue
  - getGlobalLowPriorityQueue
```
public static DispatchQueue getGlobalLowPriorityQueue()
```
    Get the global low priority queue
  - getGlobalBackgroundPriorityQueue
```
public static DispatchQueue getGlobalBackgroundPriorityQueue()
```
    Get the global background priority queue
  - getCurrentQueue
```
public static DispatchQueue getCurrentQueue()
```
    get the current queue or null if the current thread does not belong to a queue
  - isCurrentQueue
```
public boolean isCurrentQueue()
```
    Determine whether this queue is the current queue
  - dispatchSync
```
public <ReturnType> ReturnType dispatchSync(java.util.concurrent.Callable<ReturnType> rawOperation)
```
    submit the operation for execution on the queue and wait for it to complete
  - dispatchSync
```
public void dispatchSync(java.lang.Runnable rawOperation)
```
    submit the operation for execution on the queue and wait for it to complete
  - dispatchSync
```
protected void dispatchSync(java.lang.Runnable rawOperation,
                            boolean isBarrier)
```
    submit the operation for execution on the queue and wait for it to complete
  - dispatchAsync
```
public void dispatchAsync(java.lang.Runnable rawOperation)
```
    submit the operation for execution on the queue without waiting for completion
  - dispatchAsync
```
public void dispatchAsync(DispatchGroup group,
                          java.lang.Runnable rawOperation)
```
    submit the operation for execution on the queue and add it to the specified group without waiting for completion
  - dispatchAsync
```
protected void dispatchAsync(DispatchGroup group,
                             java.lang.Runnable rawOperation,
                             boolean isBarrier)
```
    submit the operation for execution on the queue and add it to the specified group without waiting for completion
  - dispatchAfter
```
public void dispatchAfter(java.util.Date dispatchTime,
                          java.lang.Runnable rawOperation)
```
    dispatch the operation after the specified time without blocking
  - dispatchBarrierAsync
```
public void dispatchBarrierAsync(java.lang.Runnable operation)
```
    Submit a barrier block for execution on the queue without waiting for completion. The barrier waits for all operations on the queue to complete before executing and then blocks all other threads on the concurrent queue until it completes. Only relevant on a concurrent queue created using createConcurrentQueue(). On all other queues, it is equivalent to dispatchAsync().
    
    Parameters:
    
    operation - the operation to execute
  - dispatchBarrierSync
```
public void dispatchBarrierSync(java.lang.Runnable operation)
```
    Submit a barrier block for execution on the queue and wait for completion. The barrier waits for all operations on the queue to complete before executing and then blocks all other threads on the concurrent queue until it completes. Only relevant on a concurrent queue created using createConcurrentQueue(). On all other queues, it is equivalent to dispatchSync().
    
    Parameters:
    
    operation - the operation to execute
  - dispatchApply
```
public void dispatchApply(int iterations,
                          DispatchIterationKernel iterationKernel)
```
    Performs all the specified iterations of the kernel asynchronously and waits for them to complete.
  - enqueueOperation
```
protected <ReturnType> void enqueueOperation(xal.tools.dispatch.DispatchOperation<ReturnType> operation)
```
    Enqueue the operation and process make sure the operation queue gets processed
  - processOperationQueue
```
protected abstract void processOperationQueue()
```
    Process the operation queue by processing the next pending operation using the serial queue processor to guarantee the operations are queue serially
  - postProcessOperation
```
protected <ReturnType> void postProcessOperation(xal.tools.dispatch.DispatchOperation<ReturnType> operation)
```
    call this method when an operation has completed execution
  - makeDispatchOperation
```
protected <ReturnType> xal.tools.dispatch.DispatchOperation<ReturnType> makeDispatchOperation(java.util.concurrent.Callable<ReturnType> rawOperation)
```
    Make a callable operation wrapper from a raw runnable operation
  - makeDispatchOperation
```
protected xal.tools.dispatch.DispatchOperation<java.lang.Void> makeDispatchOperation(java.lang.Runnable rawOperation)
```
    Make a callable operation wrapper from a raw runnable operation
  - makeDispatchOperation
```
protected xal.tools.dispatch.DispatchOperation<java.lang.Void> makeDispatchOperation(java.lang.Runnable rawOperation,
                                                                                     boolean isBarrier)
```
    Make a callable operation wrapper from a raw runnable operation
  - makeDispatchOperation
```
protected <ReturnType> xal.tools.dispatch.DispatchOperation<ReturnType> makeDispatchOperation(java.util.concurrent.Callable<ReturnType> rawOperation,
                                                                                              boolean isBarrier)
```
    Make a callable operation wrapper from a raw runnable operation
  - operationCompleted
```
public <ReturnType> void operationCompleted(xal.tools.dispatch.DispatchOperation<ReturnType> operation)
```
    Event indicating that an operation in this group has completed
  - incrementRunningOperationCount
```
protected int incrementRunningOperationCount()
```
    increment the running operations count
  - decrementRunningOperationCount
```
protected int decrementRunningOperationCount()
```
    decrement the running operations count

Class DispatchQueue

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DISPATCH_QUEUE_PRIORITY_HIGH

DISPATCH_QUEUE_PRIORITY_DEFAULT

DISPATCH_QUEUE_PRIORITY_LOW

DISPATCH_QUEUE_PRIORITY_BACKGROUND

QUEUE_PROCESSOR

DISPATCH_THREAD_FACTORY

DISPATCH_EXECUTOR

RUNNING_OPERATION_COUNTER

_queueState

PENDING_OPERATION_QUEUE

Constructor Detail

DispatchQueue

DispatchQueue

Method Detail

finalize

getLabel

isSuspended

suspend

resume

dispose

isDisposed

releaseResources

createDispatchExecutor

createConcurrentQueue

createSerialQueue

getMainQueue

getGlobalQueue

getGlobalDefaultPriorityQueue

getGlobalHighPriorityQueue

getGlobalLowPriorityQueue

getGlobalBackgroundPriorityQueue

getCurrentQueue

isCurrentQueue

dispatchSync

dispatchSync

dispatchSync

dispatchAsync

dispatchAsync

dispatchAsync

dispatchAfter

dispatchBarrierAsync

dispatchBarrierSync

dispatchApply

enqueueOperation

processOperationQueue

postProcessOperation

makeDispatchOperation

makeDispatchOperation

makeDispatchOperation

makeDispatchOperation

operationCompleted

incrementRunningOperationCount

decrementRunningOperationCount