javafixes.concurrency

Class MonitoringTaskSubmitter

java.lang.Object

javafixes.concurrency.MonitoringTaskSubmitter

Direct Known Subclasses:

Runner

public class MonitoringTaskSubmitter
extends java.lang.Object

A wrapper around ScheduledExecutorService that allows you to monitor the number of submitted, failed and succeeded task, plus has the ability to wait until all tasks scheduled trough MonitoringTaskSubmitter are completed = there are no scheduled or running tasks.

Since:

10/22/14 10:41 PM

Field Summary

Fields

Modifier and Type	Field and Description
protected java.util.concurrent.ScheduledExecutorService	executor
protected ReusableCountLatch	latch
protected org.slf4j.Logger	logger

Constructor Summary

Constructors

Constructor and Description
MonitoringTaskSubmitter(java.util.concurrent.ScheduledExecutorService executor)

Method Summary

Modifier and Type	Method and Description
int	failedCount()
int	failedSubmissionCount()
protected void	onWorkException(java.lang.Exception e)
protected void	onWorkThrowable(java.lang.Throwable t)
void	resetCounters() Resets failedSubmission, succeeded and failed counter.
<T> java.util.concurrent.Future<T>	run(java.util.concurrent.Callable<T> callable) Schedules a Callable for immediate execution.
java.util.concurrent.Future<java.lang.Void>	run(Task task) Schedules a Task 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(java.util.concurrent.Callable<T> callable) Schedules a Callable for immediate execution.
<T> java.util.concurrent.ScheduledFuture<T>	runCallableIn(long delay, java.util.concurrent.TimeUnit unit, java.util.concurrent.Callable<T> callable) Schedules a Callable for delayed execution.
<T> java.util.concurrent.ScheduledFuture<T>	runIn(long delay, java.util.concurrent.TimeUnit unit, java.util.concurrent.Callable<T> callable) Schedules a Callable for delayed execution.
java.util.concurrent.ScheduledFuture<java.lang.Void>	runIn(long delay, java.util.concurrent.TimeUnit unit, Task task) Schedules a Task for delayed execution The delay is defined using the delay and unit parameters.
java.util.concurrent.Future<java.lang.Void>	runRunnable(java.lang.Runnable runnable) Schedules a Runnable 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>	runRunnableIn(long delay, java.util.concurrent.TimeUnit unit, java.lang.Runnable runnable) Schedules a Runnable for delayed execution The delay is defined using the delay and unit parameters.
java.util.concurrent.Future<java.lang.Void>	runTask(Task task) Schedules a Task 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, Task task) Schedules a Task for delayed execution The delay is defined using the delay and unit parameters.
int	succeededCount()
int	toBeCompletedCount()
MonitoringTaskSubmitter	waitTillDone() Causes the current thread to wait until there are no unfinished tasks, unless the thread is interrupted.
boolean	waitTillDone(long timeout, java.util.concurrent.TimeUnit unit) Causes the current thread to wait until there are no unfinished tasks, unless the thread is interrupted.

Methods inherited from class java.lang.Object

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

Field Detail

logger

protected final org.slf4j.Logger logger

latch

protected final ReusableCountLatch latch

executor

protected final java.util.concurrent.ScheduledExecutorService executor

Constructor Detail

MonitoringTaskSubmitter

public MonitoringTaskSubmitter(java.util.concurrent.ScheduledExecutorService executor)

Parameters:

executor - executor that will be used to execute tasks

Method Detail

run

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

Schedules a Callable 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 - Callable to be executed

Returns:

Future referring to the state of submitted Callable

run

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

Schedules a Task 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 - Task to be executed

Returns:

Future referring to the state of submitted Task

runIn

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

Schedules a Callable 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 - Callable to be executed

Returns:

Future referring to the state of submitted Callable

runIn

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

Schedules a Task 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 - Task to be executed

Returns:

Future referring to the state of submitted Task

runCallable

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

Schedules a Callable 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 - Callable to be executed

Returns:

Future referring to the state of submitted Callable

runRunnable

public java.util.concurrent.Future<java.lang.Void> runRunnable(java.lang.Runnable runnable)

Schedules a Runnable 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:

runnable - Runnable to be executed

Returns:

Future referring to the state of submitted Runnable

runTask

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

Schedules a Task 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 - Task to be executed

Returns:

Future referring to the state of submitted Task

runCallableIn

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

Schedules a Callable 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 - Callable to be executed

Returns:

Future referring to the state of submitted Callable

runRunnableIn

public java.util.concurrent.ScheduledFuture<java.lang.Void> runRunnableIn(long delay,
                                                                          java.util.concurrent.TimeUnit unit,
                                                                          java.lang.Runnable runnable)

Schedules a Runnable 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

runnable - Runnable to be executed

Returns:

Future referring to the state of submitted Runnable

runTaskIn

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

Schedules a Task 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 - Task to be executed

Returns:

Future referring to the state of submitted Task

toBeCompletedCount

public int toBeCompletedCount()

Returns:

number of scheduled + running tasks

failedSubmissionCount

public int failedSubmissionCount()

Returns:

number of tasks that were not accepted by the executor - most possibly because it has been shut down

succeededCount

public int succeededCount()

Returns:

number of tasks that completed without throwing an exception

failedCount

public int failedCount()

Returns:

number of tasks that completed with a thrown exception

resetCounters

public void resetCounters()

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

waitTillDone

public MonitoringTaskSubmitter waitTillDone()

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.

Returns:

this MonitoringTaskSubmitter instance

Throws:

java.lang.RuntimeException - wrapping a InterruptedException if the current thread is interrupted while waiting

waitTillDone

public boolean waitTillDone(long timeout,
                            java.util.concurrent.TimeUnit unit)

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 count reaches zero then the method returns with the value true.

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.

If the specified waiting time elapses then the value false is returned. If the time is less than or equal to zero, the method will not wait at all.

Parameters:

timeout - the maximum time to wait

unit - the time unit of the timeout argument

Returns:

true if there are no tasks to be finished and false if the waiting time elapsed before the count reached zero

Throws:

java.lang.RuntimeException - wrapping a InterruptedException if the current thread is interrupted while waiting

onWorkException

protected void onWorkException(java.lang.Exception e)

onWorkThrowable

protected void onWorkThrowable(java.lang.Throwable t)