alma.acs.concurrent

Class ThreadBurstExecutorService

java.lang.Object

alma.acs.concurrent.ThreadBurstExecutorService

public class ThreadBurstExecutorService
extends java.lang.Object

Helper class that allows tests (but also other code) to be executed concurrently, in an attempt to "bombard" a tested class with parallel calls, all arriving in the smallest possible time window.

This class is similar to ExecutorService, but it synchronizes the actual execution of all threads. Note that the simple creation and starting of threads does not guarantee that these threads run after Thread.start() returns. Therefore this class does not support methods such as Executor.execute(Runnable) which execute one Runnable in one thread independently of the other threads that it runs.

An instance is good for only one burst of threads, otherwise IllegalStateException will be thrown.

Author:

hsommer

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method and Description
boolean	executeAllAndWait(long timeout, java.util.concurrent.TimeUnit unit) Unleashes all submitted (and therefore already started) threads at the same time.
<T> java.util.concurrent.Future<T>	submit(java.util.concurrent.Callable<T> task, long awaitExecutionTimeout, java.util.concurrent.TimeUnit unit) Submits a task and waits until the thread for this task has started (without yet executing the task!).
java.util.concurrent.Future<java.lang.Void>	submit(java.lang.Runnable task, long awaitExecutionTimeout, java.util.concurrent.TimeUnit unit) Variant of submit(Callable, long, TimeUnit) which gives the task as a Runnable.
boolean	terminateAllAndWait(long timeout, java.util.concurrent.TimeUnit unit) Attempts to stop all running threads, waiting no longer than the given timeout.

Methods inherited from class java.lang.Object

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

Constructor Detail

ThreadBurstExecutorService

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

Method Detail

submit

public <T> java.util.concurrent.Future<T> submit(java.util.concurrent.Callable<T> task,
                                                 long awaitExecutionTimeout,
                                                 java.util.concurrent.TimeUnit unit)
                                          throws java.lang.InterruptedException

Submits a task and waits until the thread for this task has started (without yet executing the task!). Then this thread will block until executeAllAndWait(long, TimeUnit) is called or the awaitExecutionTimeout occurs.

Parameters:

task - The task that should be executed when executeAllAndWait(long, TimeUnit) is called.

awaitExecutionTimeout - This timeout is used twice: (a) to wait for the thread to be created and started, and to wait for the user to call executeAllAndWait(long, TimeUnit).

Returns:

An object handle that can be used to wait for completion of this task, or exceptions if any are thrown (e.g. ExecutionException), or to cancel the task.

Throws:

java.lang.InterruptedException - If waiting for the thread to be created and started is interrupted.

java.lang.IllegalStateException - if executeAllAndWait(long, TimeUnit) was called already.

submit

public java.util.concurrent.Future<java.lang.Void> submit(java.lang.Runnable task,
                                                          long awaitExecutionTimeout,
                                                          java.util.concurrent.TimeUnit unit)
                                                   throws java.lang.InterruptedException

Variant of submit(Callable, long, TimeUnit) which gives the task as a Runnable. This does not allow to pass return values or exceptions from the thread to the caller, but may be more customary to use.

Throws:

java.lang.InterruptedException

executeAllAndWait

public boolean executeAllAndWait(long timeout,
                                 java.util.concurrent.TimeUnit unit)
                          throws java.lang.InterruptedException

Unleashes all submitted (and therefore already started) threads at the same time. Then waits until all tasks finish, or until the given timeout occurs.

This method must only be called once for a given instance of ThreadBurstExecutor.

Returns:

true if all tasks have run, and false if the timeout elapsed before termination.

Throws:

java.lang.IllegalStateException - if executeAllAndWait(long, TimeUnit) was called already.

java.lang.InterruptedException - If waiting for the tasks to finish was interrupted.

terminateAllAndWait

public boolean terminateAllAndWait(long timeout,
                                   java.util.concurrent.TimeUnit unit)
                            throws java.lang.InterruptedException

Attempts to stop all running threads, waiting no longer than the given timeout. This method can be called either before executeAllAndWait(long, java.util.concurrent.TimeUnit) to stop the threads that block on the thread gate to open, or afterwards to stop running tasks.

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.

Parameters:

timeout -

unit - time unit

Returns:

true if this executor terminated and false if the timeout elapsed before termination

Throws:

java.lang.InterruptedException