Package com.complexible.common.util.concurrent

Class ExecutionGroup

java.lang.Object

com.complexible.common.util.concurrent.ExecutionGroup

public abstract class ExecutionGroup
extends Object

A very light-weight utility class to make it easier to run a set of tasks together and wait until all those jobs end. The tasks can be run concurrently or sequentially depending on what kind of group has been created.

Since:

0.9

Version:

2.0

Author:

Evren Sirin, Michael Grove

Constructor Summary

Constructors

Constructor	Description
ExecutionGroup()

Method Summary

Modifier and Type	Method	Description
ExecutionGroup	add(Callable<?> theTask)
ExecutionGroup	addAll(Iterable<Callable<?>> theTasks)
ExecutionGroup	addAll(Iterator<Callable<?>> theTasks)
static ExecutionGroup	concurrent(ExecutorService theExecutorService)
abstract Iterable<Future<?>>	execute()
void	executeAndWait()
abstract void	executeAndWait(boolean theUninterruptible)	Waits until all the tasks of this group have finished.
abstract boolean	isExecuting()
protected abstract void	performAdd(Callable<?> theTask)
static ExecutionGroup	sequential()

Methods inherited from class java.lang.Object

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

Constructor Details

ExecutionGroup

public ExecutionGroup()

Method Details

add

public ExecutionGroup add(Callable<?> theTask)

addAll

public ExecutionGroup addAll(Iterator<Callable<?>> theTasks)

addAll

public ExecutionGroup addAll(Iterable<Callable<?>> theTasks)

performAdd

protected abstract void performAdd(Callable<?> theTask)

executeAndWait

public void executeAndWait()
                    throws ExecutionException,
InterruptedException

Throws:

ExecutionException

InterruptedException

executeAndWait

public abstract void executeAndWait(boolean theUninterruptible)
                             throws ExecutionException,
InterruptedException

Waits until all the tasks of this group have finished.

Parameters:

theUninterruptible - if true, the wait is not abandoned when the calling thread gets interrupted (the interrupt status is restored before returning) and thus never returns while a task can still be running. Pass true when the tasks work on resources whose lifetime is bound to the caller, so abandoning them is not an option; such tasks have to stop cooperatively, e.g. via a cancellation check they share with the caller. If false, an interrupt cancels the futures and returns immediately, which does not mean that the tasks have stopped.

Throws:

ExecutionException

InterruptedException

execute

public abstract Iterable<Future<?>> execute()
                                     throws ExecutionException,
InterruptedException

Throws:

ExecutionException

InterruptedException

isExecuting

public abstract boolean isExecuting()

concurrent

public static ExecutionGroup concurrent(ExecutorService theExecutorService)

sequential

public static ExecutionGroup sequential()