co.paralleluniverse.concurrent.util

Class ScheduledSingleThreadExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

co.paralleluniverse.concurrent.util.ScheduledSingleThreadExecutor

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService, java.util.concurrent.ScheduledExecutorService

public class ScheduledSingleThreadExecutor
extends java.util.concurrent.AbstractExecutorService
implements java.util.concurrent.ScheduledExecutorService

This is a replacement for ScheduledThreadPoolExecutor, with the following characteristics:

1. It uses a single worker thread, so it should only execute very brief tasks.
2. Its submission queue does not block producers.

This makes this executor particularly suitable for cases when many threads schedule many tasks that simply submit other tasks to another executor.

Constructor Summary

Constructors

Constructor and Description
ScheduledSingleThreadExecutor()
ScheduledSingleThreadExecutor(java.util.concurrent.ThreadFactory threadFactory)

Method Summary

Modifier and Type	Method and Description
boolean	awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)
protected <V> java.util.concurrent.RunnableScheduledFuture<V>	decorateTask(java.util.concurrent.Callable<V> callable, java.util.concurrent.RunnableScheduledFuture<V> task) Modifies or replaces the task used to execute a callable.
protected <V> java.util.concurrent.RunnableScheduledFuture<V>	decorateTask(java.lang.Runnable runnable, java.util.concurrent.RunnableScheduledFuture<V> task) Modifies or replaces the task used to execute a runnable.
void	execute(java.lang.Runnable command) Executes command with zero required delay.
int	getActiveCount() Returns the approximate number of threads that are actively executing tasks.
boolean	getContinueExistingPeriodicTasksAfterShutdownPolicy() Gets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
boolean	getExecuteExistingDelayedTasksAfterShutdownPolicy() Gets the policy on whether to execute existing delayed tasks even when this executor has been shutdown.
int	getPoolSize() Returns the current number of threads in the pool.
boolean	getRemoveOnCancelPolicy() Gets the policy on whether cancelled tasks should be immediately removed from the work queue at time of cancellation.
boolean	isShutdown()
boolean	isTerminated()
protected void	reject(java.lang.Runnable command)
<V> java.util.concurrent.ScheduledFuture<V>	schedule(java.util.concurrent.Callable<V> callable, long delay, java.util.concurrent.TimeUnit unit)
java.util.concurrent.ScheduledFuture<?>	schedule(java.lang.Runnable command, long delay, java.util.concurrent.TimeUnit unit)
java.util.concurrent.ScheduledFuture<?>	scheduleAtFixedRate(java.lang.Runnable command, long initialDelay, long period, java.util.concurrent.TimeUnit unit)
java.util.concurrent.ScheduledFuture<?>	scheduleWithFixedDelay(java.lang.Runnable command, long initialDelay, long delay, java.util.concurrent.TimeUnit unit)
void	setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) Sets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown.
void	setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) Sets the policy on whether to execute existing delayed tasks even when this executor has been shutdown.
void	setRemoveOnCancelPolicy(boolean value) Sets the policy on whether cancelled tasks should be immediately removed from the work queue at time of cancellation.
void	shutdown() Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted.
java.util.List<java.lang.Runnable>	shutdownNow() Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.
<T> java.util.concurrent.Future<T>	submit(java.util.concurrent.Callable<T> task)
java.util.concurrent.Future<?>	submit(java.lang.Runnable task)
<T> java.util.concurrent.Future<T>	submit(java.lang.Runnable task, T result)

Methods inherited from class java.util.concurrent.AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor

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

Constructor Detail

ScheduledSingleThreadExecutor

public ScheduledSingleThreadExecutor(java.util.concurrent.ThreadFactory threadFactory)

ScheduledSingleThreadExecutor

public ScheduledSingleThreadExecutor()

Method Detail

reject

protected void reject(java.lang.Runnable command)

decorateTask

protected <V> java.util.concurrent.RunnableScheduledFuture<V> decorateTask(java.lang.Runnable runnable,
                                                                           java.util.concurrent.RunnableScheduledFuture<V> task)

Modifies or replaces the task used to execute a runnable. This method can be used to override the concrete class used for managing internal tasks. The default implementation simply returns the given task.

Parameters:

runnable - the submitted Runnable

task - the task created to execute the runnable

Returns:

a task that can execute the runnable

Since:

1.6

decorateTask

protected <V> java.util.concurrent.RunnableScheduledFuture<V> decorateTask(java.util.concurrent.Callable<V> callable,
                                                                           java.util.concurrent.RunnableScheduledFuture<V> task)

Modifies or replaces the task used to execute a callable. This method can be used to override the concrete class used for managing internal tasks. The default implementation simply returns the given task.

Parameters:

callable - the submitted Callable

task - the task created to execute the callable

Returns:

a task that can execute the callable

Since:

1.6

schedule

public java.util.concurrent.ScheduledFuture<?> schedule(java.lang.Runnable command,
                                                        long delay,
                                                        java.util.concurrent.TimeUnit unit)

Specified by:

schedule in interface java.util.concurrent.ScheduledExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

schedule

public <V> java.util.concurrent.ScheduledFuture<V> schedule(java.util.concurrent.Callable<V> callable,
                                                            long delay,
                                                            java.util.concurrent.TimeUnit unit)

Specified by:

schedule in interface java.util.concurrent.ScheduledExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

scheduleAtFixedRate

public java.util.concurrent.ScheduledFuture<?> scheduleAtFixedRate(java.lang.Runnable command,
                                                                   long initialDelay,
                                                                   long period,
                                                                   java.util.concurrent.TimeUnit unit)

Specified by:

scheduleAtFixedRate in interface java.util.concurrent.ScheduledExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

java.lang.IllegalArgumentException

scheduleWithFixedDelay

public java.util.concurrent.ScheduledFuture<?> scheduleWithFixedDelay(java.lang.Runnable command,
                                                                      long initialDelay,
                                                                      long delay,
                                                                      java.util.concurrent.TimeUnit unit)

Specified by:

scheduleWithFixedDelay in interface java.util.concurrent.ScheduledExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

java.lang.IllegalArgumentException

execute

public void execute(java.lang.Runnable command)

Executes command with zero required delay. This has effect equivalent to schedule(command, 0, anyUnit). Note that inspections of the queue and of the list returned by shutdownNow will access the zero-delayed ScheduledFuture, not the command itself.

A consequence of the use of ScheduledFuture objects is that afterExecute is always called with a null second Throwable argument, even if the command terminated abruptly. Instead, the Throwable thrown by such a task can be obtained via Future.get().

Specified by:

execute in interface java.util.concurrent.Executor

Throws:

java.util.concurrent.RejectedExecutionException - at discretion of RejectedExecutionHandler, if the task cannot be accepted for execution because the executor has been shut down

java.lang.NullPointerException

submit

public java.util.concurrent.Future<?> submit(java.lang.Runnable task)

Specified by:

submit in interface java.util.concurrent.ExecutorService

Overrides:

submit in class java.util.concurrent.AbstractExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

submit

public <T> java.util.concurrent.Future<T> submit(java.lang.Runnable task,
                                                 T result)

Specified by:

submit in interface java.util.concurrent.ExecutorService

Overrides:

submit in class java.util.concurrent.AbstractExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

submit

public <T> java.util.concurrent.Future<T> submit(java.util.concurrent.Callable<T> task)

Specified by:

submit in interface java.util.concurrent.ExecutorService

Overrides:

submit in class java.util.concurrent.AbstractExecutorService

Throws:

java.util.concurrent.RejectedExecutionException

java.lang.NullPointerException

setContinueExistingPeriodicTasksAfterShutdownPolicy

public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value)

Sets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown. In this case, these tasks will only terminate upon shutdownNow or after setting the policy to false when already shutdown. This value is by default false.

Parameters:

value - if true, continue after shutdown, else don't

See Also:

getContinueExistingPeriodicTasksAfterShutdownPolicy()

getContinueExistingPeriodicTasksAfterShutdownPolicy

public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy()

Gets the policy on whether to continue executing existing periodic tasks even when this executor has been shutdown. In this case, these tasks will only terminate upon shutdownNow or after setting the policy to false when already shutdown. This value is by default false.

Returns:

true if will continue after shutdown

See Also:

setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean)

setExecuteExistingDelayedTasksAfterShutdownPolicy

public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value)

Sets the policy on whether to execute existing delayed tasks even when this executor has been shutdown. In this case, these tasks will only terminate upon shutdownNow, or after setting the policy to false when already shutdown. This value is by default true.

Parameters:

value - if true, execute after shutdown, else don't

See Also:

getExecuteExistingDelayedTasksAfterShutdownPolicy()

getExecuteExistingDelayedTasksAfterShutdownPolicy

public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy()

Gets the policy on whether to execute existing delayed tasks even when this executor has been shutdown. In this case, these tasks will only terminate upon shutdownNow, or after setting the policy to false when already shutdown. This value is by default true.

Returns:

true if will execute after shutdown

See Also:

setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean)

setRemoveOnCancelPolicy

public void setRemoveOnCancelPolicy(boolean value)

Sets the policy on whether cancelled tasks should be immediately removed from the work queue at time of cancellation. This value is by default false.

Parameters:

value - if true, remove on cancellation, else don't

Since:

1.7

See Also:

getRemoveOnCancelPolicy()

getRemoveOnCancelPolicy

public boolean getRemoveOnCancelPolicy()

Gets the policy on whether cancelled tasks should be immediately removed from the work queue at time of cancellation. This value is by default false.

Returns:

true if cancelled tasks are immediately removed from the queue

Since:

1.7

See Also:

setRemoveOnCancelPolicy(boolean)

shutdown

public void shutdown()

Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down.

This method does not wait for previously submitted tasks to complete execution. Use awaitTermination to do that.

If the ExecuteExistingDelayedTasksAfterShutdownPolicy has been set false, existing delayed tasks whose delays have not yet elapsed are cancelled. And unless the ContinueExistingPeriodicTasksAfterShutdownPolicy has been set true, future executions of existing periodic tasks will be cancelled.

Specified by:

shutdown in interface java.util.concurrent.ExecutorService

Throws:

java.lang.SecurityException

shutdownNow

public java.util.List<java.lang.Runnable> shutdownNow()

Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.

This method does not wait for actively executing tasks to terminate. Use awaitTermination to do that.

There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. This implementation cancels tasks via Thread.interrupt(), so any task that fails to respond to interrupts may never terminate.

Specified by:

shutdownNow in interface java.util.concurrent.ExecutorService

Returns:

list of tasks that never commenced execution. Each element of this list is a ScheduledFuture, including those tasks submitted using execute, which are for scheduling purposes used as the basis of a zero-delay ScheduledFuture.

Throws:

java.lang.SecurityException

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

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

getPoolSize

public int getPoolSize()

Returns the current number of threads in the pool.

Returns:

the number of threads

getActiveCount

public int getActiveCount()

Returns the approximate number of threads that are actively executing tasks.

Returns:

the number of threads