org.jdiagnose.concurrent
Class QueuedExecutor

java.lang.Object
  org.jdiagnose.concurrent.ThreadFactoryUser
      org.jdiagnose.concurrent.QueuedExecutor

All Implemented Interfaces:

Executor

public class QueuedExecutor

extends ThreadFactoryUser

implements Executor

An implementation of Executor that queues incoming requests until they can be processed by a single background thread.

The thread is not actually started until the first execute request is encountered. Also, if the thread is stopped for any reason (for example, after hitting an unrecoverable exception in an executing task), one is started upon encountering a new request, or if restart() is invoked.

Beware that, especially in situations where command objects themselves invoke execute, queuing can sometimes lead to lockups, since commands that might allow other threads to terminate do not run at all when they are in the queue.

[ Introduction to this package. ]

Nested Class Summary

protected class

QueuedExecutor.RunLoop The runloop is isolated in its own Runnable class just so that the main class need not implement Runnable, which would allow others to directly invoke run, which would never make sense here.

Nested classes inherited from class org.jdiagnose.concurrent.ThreadFactoryUser

ThreadFactoryUser.DefaultThreadFactory

Field Summary

protected static java.lang.Runnable	ENDTASK Special queue element to signal termination
protected Channel	queue_ The queue
protected QueuedExecutor.RunLoop	runLoop_
protected boolean	shutdown_ true if thread should shut down after processing current task
protected java.lang.Thread	thread_ The thread used to process commands

Fields inherited from class org.jdiagnose.concurrent.ThreadFactoryUser

threadFactory_

Constructor Summary

QueuedExecutor()
Construct a new QueuedExecutor that uses a BoundedLinkedQueue with the current DefaultChannelCapacity as its queue.

QueuedExecutor(Channel queue)
Construct a new QueuedExecutor that uses the supplied Channel as its queue.

Method Summary

protected void	clearThread() set thread_ to null to indicate termination
void	execute(java.lang.Runnable command) Arrange for execution of the command in the background thread by adding it to the queue.
java.lang.Thread	getThread() Return the thread being used to process commands, or null if there is no such thread.
void	restart() Start (or restart) the background thread to process commands.
void	shutdownAfterProcessingCurrentlyQueuedTasks() Terminate background thread after it processes all elements currently in queue.
void	shutdownAfterProcessingCurrentTask() Terminate background thread after it processes the current task, removing other queued tasks and leaving them unprocessed.
void	shutdownNow() Terminate background thread even if it is currently processing a task.

Methods inherited from class org.jdiagnose.concurrent.ThreadFactoryUser

getThreadFactory, setThreadFactory

Methods inherited from class java.lang.Object

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

Field Detail

thread_

protected java.lang.Thread thread_

The thread used to process commands

ENDTASK

protected static java.lang.Runnable ENDTASK

Special queue element to signal termination

shutdown_

protected volatile boolean shutdown_

true if thread should shut down after processing current task

queue_

protected final Channel queue_

The queue

runLoop_

protected final QueuedExecutor.RunLoop runLoop_

Constructor Detail

QueuedExecutor

public QueuedExecutor(Channel queue)

Construct a new QueuedExecutor that uses the supplied Channel as its queue.

This class does not support any methods that reveal this queue. If you need to access it independently (for example to invoke any special status monitoring operations), you should record a reference to it separately.

QueuedExecutor

public QueuedExecutor()

Construct a new QueuedExecutor that uses a BoundedLinkedQueue with the current DefaultChannelCapacity as its queue.

Method Detail

getThread

public java.lang.Thread getThread()

Return the thread being used to process commands, or null if there is no such thread. You can use this to invoke any special methods on the thread, for example, to interrupt it.

clearThread

protected void clearThread()

set thread_ to null to indicate termination

restart

public void restart()

Start (or restart) the background thread to process commands. It has no effect if a thread is already running. This method can be invoked if the background thread crashed due to an unrecoverable exception.

execute

public void execute(java.lang.Runnable command)
             throws java.lang.InterruptedException

Arrange for execution of the command in the background thread by adding it to the queue. The method may block if the channel's put operation blocks.

If the background thread does not exist, it is created and started.

Specified by:

execute in interface Executor

Throws:

java.lang.InterruptedException

shutdownAfterProcessingCurrentlyQueuedTasks

public void shutdownAfterProcessingCurrentlyQueuedTasks()

Terminate background thread after it processes all elements currently in queue. Any tasks entered after this point will not be processed. A shut down thread cannot be restarted. This method may block if the task queue is finite and full. Also, this method does not in general apply (and may lead to comparator-based exceptions) if the task queue is a priority queue.

shutdownAfterProcessingCurrentTask

public void shutdownAfterProcessingCurrentTask()

Terminate background thread after it processes the current task, removing other queued tasks and leaving them unprocessed. A shut down thread cannot be restarted.

shutdownNow

public void shutdownNow()

Terminate background thread even if it is currently processing a task. This method uses Thread.interrupt, so relies on tasks themselves responding appropriately to interruption. If the current tasks does not terminate on interruption, then the thread will not terminate until processing current task. A shut down thread cannot be restarted.