javafixes.concurrency

Class Runner

java.lang.Object

javafixes.concurrency.MonitoringTaskSubmitter

javafixes.concurrency.Runner

All Implemented Interfaces:

java.lang.AutoCloseable, ShutdownInfo

public class Runner
extends MonitoringTaskSubmitter
implements ShutdownInfo, java.lang.AutoCloseable

An ScheduledExecutorService alternative that allows you to monitor the number of submitted, failed and succeeded task, plus has the ability to wait until all tasks are completed (without the need of shutting it down) = wait until there are no scheduled or running tasks.

Field Summary

Fields inherited from class javafixes.concurrency.MonitoringTaskSubmitter

executor, latch, logger

Constructor Summary

Constructors

Constructor and Description
Runner(int threadCount) Constructs a runner with specific number of executor thread.

Method Summary

Modifier and Type	Method and Description
Runner	awaitTermination(long timeout, java.util.concurrent.TimeUnit unit) Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
void	close() Sends a shutdownNow signal to the runner.
int	failedToStartCount()
protected void	finalize()
void	resetCounters() Resets failedSubmission, failedToStart, succeeded and failed counter.
<T> java.util.concurrent.Future<T>	run(ShutdownAwareCallable<T> callable) Schedules a ShutdownAwareCallable for immediate execution.
java.util.concurrent.Future<java.lang.Void>	run(ShutdownAwareTask task) Schedules a ShutdownAwareTask for immediate execution It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.
<T> java.util.concurrent.Future<T>	runCallable(ShutdownAwareCallable<T> callable) Schedules a ShutdownAwareCallable for immediate execution.
<T> java.util.concurrent.ScheduledFuture<T>	runCallableIn(long delay, java.util.concurrent.TimeUnit unit, ShutdownAwareCallable<T> callable) Schedules a ShutdownAwareCallable for delayed execution.
<T> java.util.concurrent.ScheduledFuture<T>	runIn(long delay, java.util.concurrent.TimeUnit unit, ShutdownAwareCallable<T> callable) Schedules a ShutdownAwareCallable for delayed execution.
java.util.concurrent.ScheduledFuture<java.lang.Void>	runIn(long delay, java.util.concurrent.TimeUnit unit, ShutdownAwareTask task) Schedules a ShutdownAwareTask for delayed execution The delay is defined using the delay and unit parameters.
static Runner	runner(int threadCount) Factory method to create a Runner.
java.util.concurrent.Future<java.lang.Void>	runTask(ShutdownAwareTask task) Schedules a ShutdownAwareTask for immediate execution It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.
java.util.concurrent.ScheduledFuture<java.lang.Void>	runTaskIn(long delay, java.util.concurrent.TimeUnit unit, ShutdownAwareTask task) Schedules a ShutdownAwareTask for delayed execution The delay is defined using the delay and unit parameters.
Runner	shutdown() Sends a shutdown signal to the runner.
Runner	shutdownAndAwaitTermination() Calls shutdown() and awaitTermination(long, TimeUnit) methods in sequence where the timeout is set to 5 seconds.
Runner	shutdownAndAwaitTermination(long timeout, java.util.concurrent.TimeUnit unit) Calls shutdown() and awaitTermination(long, TimeUnit) methods in sequence
Runner	shutdownNow() Sends a shutdownNow signal to the runner.
Runner	shutdownNowAndAwaitTermination() Calls shutdownNow() and awaitTermination(long, TimeUnit) methods in sequence where the timeout is set to 5 seconds.
Runner	shutdownNowAndAwaitTermination(long timeout, java.util.concurrent.TimeUnit unit) Calls shutdownNow() and awaitTermination(long, TimeUnit) methods in sequence
Runner	waitTillDone() Causes the current thread to wait until there are no unfinished tasks, unless the thread is interrupted.
boolean	wasShutdownTriggered() Returns true if any shutdown operation has been called on this Runner.

Methods inherited from class javafixes.concurrency.MonitoringTaskSubmitter

failedCount, failedSubmissionCount, onWorkException, onWorkThrowable, run, run, runCallable, runCallableIn, runIn, runIn, runRunnable, runRunnableIn, runTask, runTaskIn, succeededCount, toBeCompletedCount, waitTillDone

Methods inherited from class java.lang.Object

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

Constructor Detail

Runner

public Runner(int threadCount)

Constructs a runner with specific number of executor thread.

Parameters:

threadCount - number of executor threads

Method Detail

runner

public static Runner runner(int threadCount)

Factory method to create a Runner.

Parameters:

threadCount - number of executor threads

Returns:

new Runner

run

public <T> java.util.concurrent.Future<T> run(ShutdownAwareCallable<T> callable)

Schedules a ShutdownAwareCallable for immediate execution. It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Type Parameters:

T - type of return value

Parameters:

callable - ShutdownAwareCallable to be executed

Returns:

Future referring to the state of submitted ShutdownAwareCallable

run

public java.util.concurrent.Future<java.lang.Void> run(ShutdownAwareTask task)

Schedules a ShutdownAwareTask for immediate execution It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Parameters:

task - ShutdownAwareTask to be executed

Returns:

Future referring to the state of submitted ShutdownAwareTask

runIn

public <T> java.util.concurrent.ScheduledFuture<T> runIn(long delay,
                                                         java.util.concurrent.TimeUnit unit,
                                                         ShutdownAwareCallable<T> callable)

Schedules a ShutdownAwareCallable for delayed execution. The delay is defined using the delay and unit parameters. It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Type Parameters:

T - type of return value

Parameters:

delay - the value of the delay

unit - the TimeUnit of the delay argument

callable - ShutdownAwareCallable to be executed

Returns:

Future referring to the state of submitted ShutdownAwareCallable

runIn

public java.util.concurrent.ScheduledFuture<java.lang.Void> runIn(long delay,
                                                                  java.util.concurrent.TimeUnit unit,
                                                                  ShutdownAwareTask task)

Schedules a ShutdownAwareTask for delayed execution The delay is defined using the delay and unit parameters. It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Parameters:

delay - the value of the delay

unit - the TimeUnit of the delay argument

task - ShutdownAwareTask to be executed

Returns:

Future referring to the state of submitted ShutdownAwareTask

runCallable

public <T> java.util.concurrent.Future<T> runCallable(ShutdownAwareCallable<T> callable)

Schedules a ShutdownAwareCallable for immediate execution. It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Type Parameters:

T - type of return value

Parameters:

callable - ShutdownAwareCallable to be executed

Returns:

Future referring to the state of submitted ShutdownAwareCallable

runTask

public java.util.concurrent.Future<java.lang.Void> runTask(ShutdownAwareTask task)

Schedules a ShutdownAwareTask for immediate execution It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Parameters:

task - ShutdownAwareTask to be executed

Returns:

Future referring to the state of submitted ShutdownAwareTask

runCallableIn

public <T> java.util.concurrent.ScheduledFuture<T> runCallableIn(long delay,
                                                                 java.util.concurrent.TimeUnit unit,
                                                                 ShutdownAwareCallable<T> callable)

Schedules a ShutdownAwareCallable for delayed execution. The delay is defined using the delay and unit parameters. It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Type Parameters:

T - type of return value

Parameters:

delay - the value of the delay

unit - the TimeUnit of the delay argument

callable - ShutdownAwareCallable to be executed

Returns:

Future referring to the state of submitted ShutdownAwareCallable

runTaskIn

public java.util.concurrent.ScheduledFuture<java.lang.Void> runTaskIn(long delay,
                                                                      java.util.concurrent.TimeUnit unit,
                                                                      ShutdownAwareTask task)

Schedules a ShutdownAwareTask for delayed execution The delay is defined using the delay and unit parameters. It might be executed later though if the ScheduledExecutorService has no available threads or more tasks are queued for execution before this task.

Parameters:

delay - the value of the delay

unit - the TimeUnit of the delay argument

task - ShutdownAwareTask to be executed

Returns:

Future referring to the state of submitted ShutdownAwareTask

waitTillDone

public Runner waitTillDone()

Description copied from class: MonitoringTaskSubmitter

Causes the current thread to wait until there are no unfinished tasks, unless the thread is interrupted.

If the current count of to be finished tasks is zero then this method returns immediately.

If the current count is greater than zero then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of two things happen:

• The count reaches zero due to completion of all to be finished tasks or
• Some other thread interrupts the current thread.

If the current thread:

• has its interrupted status set on entry to this method; or
• is interrupted while waiting,

then RuntimeException wrapping an InterruptedException is thrown and the current thread's interrupted status is cleared.

Overrides:

waitTillDone in class MonitoringTaskSubmitter

Returns:

this MonitoringTaskSubmitter instance

shutdown

public Runner shutdown()

Sends a shutdown signal to the runner.

Returns:

this Runner instance

See Also:

ExecutorService.shutdown()

shutdownNow

public Runner shutdownNow()

Sends a shutdownNow signal to the runner.

Returns:

this Runner instance

See Also:

ExecutorService.shutdownNow()

close

public void close()
           throws java.lang.Exception

Sends a shutdownNow signal to the runner.

Specified by:

close in interface java.lang.AutoCloseable

Throws:

java.lang.Exception

See Also:

ExecutorService.shutdownNow()

wasShutdownTriggered

public boolean wasShutdownTriggered()

Returns true if any shutdown operation has been called on this Runner. In this case the Runner won't accept any new tasks for execution.

Specified by:

wasShutdownTriggered in interface ShutdownInfo

Returns:

true if shutdown on the Runner has been triggered

awaitTermination

public Runner awaitTermination(long timeout,
                               java.util.concurrent.TimeUnit unit)

Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

Returns:

this Runner instance

Throws:

java.lang.RuntimeException - wrapping an InterruptedException if interrupted while waiting

shutdownAndAwaitTermination

public Runner shutdownAndAwaitTermination(long timeout,
                                          java.util.concurrent.TimeUnit unit)

Calls shutdown() and awaitTermination(long, TimeUnit) methods in sequence

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

Returns:

this Runner instance

Throws:

java.lang.RuntimeException - wrapping an InterruptedException if interrupted while waiting

shutdownAndAwaitTermination

public Runner shutdownAndAwaitTermination()

Calls shutdown() and awaitTermination(long, TimeUnit) methods in sequence where the timeout is set to 5 seconds.

Returns:

this Runner instance

Throws:

java.lang.RuntimeException - wrapping an InterruptedException if interrupted while waiting

shutdownNowAndAwaitTermination

public Runner shutdownNowAndAwaitTermination(long timeout,
                                             java.util.concurrent.TimeUnit unit)

Calls shutdownNow() and awaitTermination(long, TimeUnit) methods in sequence

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

Returns:

this Runner instance

Throws:

java.lang.RuntimeException - wrapping an InterruptedException if interrupted while waiting

shutdownNowAndAwaitTermination

public Runner shutdownNowAndAwaitTermination()

Calls shutdownNow() and awaitTermination(long, TimeUnit) methods in sequence where the timeout is set to 5 seconds.

Returns:

this Runner instance

Throws:

java.lang.RuntimeException - wrapping an InterruptedException if interrupted while waiting

failedToStartCount

public int failedToStartCount()

Returns:

number of tasks that were initially accepted by the executor but removed before they would start - most possibly because the executor has been shut down

resetCounters

public void resetCounters()

Resets failedSubmission, failedToStart, succeeded and failed counter. It doesn't reset the toBeFinished counter as it is a derived number from the number of scheduled + running tasks.

Overrides:

resetCounters in class MonitoringTaskSubmitter

finalize

protected void finalize()
                 throws java.lang.Throwable

Overrides:

finalize in class java.lang.Object

Throws:

java.lang.Throwable