org.openbase.jul.schedule

Class AbstractExecutorService<ES extends ThreadPoolExecutor>

java.lang.Object

org.openbase.jul.schedule.AbstractExecutorService<ES>

Type Parameters:

ES - The internal execution service.

All Implemented Interfaces:

org.openbase.jul.iface.Shutdownable

Direct Known Subclasses:

GlobalCachedExecutorService, GlobalScheduledExecutorService

public abstract class AbstractExecutorService<ES extends ThreadPoolExecutor>
extends Object
implements org.openbase.jul.iface.Shutdownable

Author:

Divine Threepwood

Nested Class Summary

Nested classes/interfaces inherited from interface org.openbase.jul.iface.Shutdownable

org.openbase.jul.iface.Shutdownable.ShutdownDeamon

Field Summary

Fields

Modifier and Type	Field and Description
static long	DEFAULT_REPORT_RATE Report rate for the debug mode in milliseconds.
static long	DEFAULT_SHUTDOWN_DELAY Default shutdown delay in milliseconds.
static long	DEFAULT_SHUTDOWN_TIME Default shutdown time in milliseconds.
static double	DEFAULT_WARNING_RATIO The ratio of the threads which can be used until pool overload warnings are periodically printed.
protected ES	executorService The internally used executor service.
protected org.slf4j.Logger	logger
static long	SMART_SHUTDOWN_STATUS_PRINT_RATE The rate for printing feedback if the shutdown is delayed.
static long	SMART_SHUTDOWN_TIMEOUT Default shutdown time in milliseconds.

Constructor Summary

Constructors

Constructor and Description
AbstractExecutorService(ES executorService)

Method Summary

Modifier and Type	Method and Description
static <R> Future<R>	allOf(Callable<R> resultCallable, Collection<Future> futureCollection) Method generates a new futures which represents all futures provided by the futureCollection.
static <R> Future<R>	allOf(Callable resultCallable, Future... futures)
static <R> Future<R>	allOf(Collection<Future> futureCollection)
static <I,O,R> Future<R>	allOf(Collection<I> inputList, org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor, org.openbase.jul.iface.Processable<I,Future<O>> taskProcessor)
static <I,R> Future<R>	allOf(Collection<I> inputList, org.openbase.jul.iface.Processable<I,Future<R>> taskProcessor)
static <R> Future<R>	allOf(ExecutorService executorService, Callable<R> resultCallable, Collection<Future> futureCollection) Method generates a new futures which represents all futures provided by the futureCollection.
static <I,O,R> Future<R>	allOf(ExecutorService executorService, Collection<I> inputList, org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor, org.openbase.jul.iface.Processable<I,Future<O>> taskProcessor)
static <I,R> Future<R>	allOf(ExecutorService executorService, Collection<I> inputList, org.openbase.jul.iface.Processable<I,Future<Void>> taskProcessor)
static <O,R> Future<R>	allOf(ExecutorService executorService, org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor, Collection<Future<O>> futureCollection) Method generates a new futures which represents all futures provided by the futureCollection.
static <R> Future<R>	allOf(ExecutorService executorService, R returnValue, Collection<Future> futureCollection)
static Future<Void>	allOf(Future... futures)
static <O,R> Future<R>	allOf(org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor, Collection<Future<O>> futureCollection) Method generates a new futures which represents all futures provided by the futureCollection.If all futures are successfully finished the outer future will be completed with the result provided by the resultProcessor.
static <R> Future<R>	allOf(R returnValue, Collection<Future> futureCollection)
static <R> Future<R>	allOfInclusiveResultFuture(Future<R> resultFuture, Future... futures)
static Future	applyErrorHandling(Future future, org.openbase.jul.iface.Processable<Exception,Void> errorProcessor, long timeout, TimeUnit timeUnit) This method applies an error handler to the given future object.
static Future	applyErrorHandling(Future future, org.openbase.jul.iface.Processable<Exception,Void> errorProcessor, long timeout, TimeUnit timeUnit, ExecutorService executorService) This method applies an error handler to the given future object.
static <R> Future<R>	atLeastOne(Callable<R> resultCallable, Collection<Future> futureCollection, long timeout, TimeUnit timeUnit)
static <R> Future<R>	atLeastOne(ExecutorService executorService, Callable<R> resultCallable, Collection<Future> futureCollection, long timeout, TimeUnit timeUnit) Method generates a new futures which represents all futures provided by the futureCollection.
static <R> Future<R>	atLeastOne(R returnValue, Collection<Future> futureCollection, long timeout, TimeUnit timeUnit)
static <I,O> Collection<Future<O>>	buildFutureCollection(Collection<I> inputList, org.openbase.jul.iface.Processable<I,Future<O>> taskProcessor) Method builds a future collection with the given task processor.
void	forceShutdown()
int	getExecutorLoad()
ES	getExecutorService()
void	internalExecute(Runnable runnable)
<T> Future<T>	internalSubmit(Callable<T> task)
Future<?>	internalSubmit(Runnable task)
void	shutdown()
void	shutdown(long shutdownTimeout, TimeUnit timeUnit)
void	smartShutdown()
String	toString() Simply prints the class name.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.openbase.jul.iface.Shutdownable

registerShutdownHook, registerShutdownHook

Field Detail

DEFAULT_SHUTDOWN_DELAY

public static final long DEFAULT_SHUTDOWN_DELAY

Default shutdown delay in milliseconds.

See Also:

Constant Field Values

DEFAULT_SHUTDOWN_TIME

public static final long DEFAULT_SHUTDOWN_TIME

Default shutdown time in milliseconds.

See Also:

Constant Field Values

SMART_SHUTDOWN_TIMEOUT

public static final long SMART_SHUTDOWN_TIMEOUT

Default shutdown time in milliseconds.

See Also:

Constant Field Values

SMART_SHUTDOWN_STATUS_PRINT_RATE

public static final long SMART_SHUTDOWN_STATUS_PRINT_RATE

The rate for printing feedback if the shutdown is delayed.

See Also:

Constant Field Values

DEFAULT_REPORT_RATE

public static final long DEFAULT_REPORT_RATE

Report rate for the debug mode in milliseconds.

See Also:

Constant Field Values

DEFAULT_WARNING_RATIO

public static final double DEFAULT_WARNING_RATIO

The ratio of the threads which can be used until pool overload warnings are periodically printed.

See Also:

Constant Field Values

executorService

protected final ES extends ThreadPoolExecutor executorService

The internally used executor service.

logger

protected final org.slf4j.Logger logger

Constructor Detail

AbstractExecutorService

public AbstractExecutorService(ES executorService)
                        throws CouldNotPerformException

Throws:

CouldNotPerformException

Method Detail

getExecutorLoad

public int getExecutorLoad()

internalSubmit

public <T> Future<T> internalSubmit(Callable<T> task)

internalSubmit

public Future<?> internalSubmit(Runnable task)

internalExecute

public void internalExecute(Runnable runnable)

getExecutorService

public ES getExecutorService()

shutdown

public void shutdown()

Specified by:

shutdown in interface org.openbase.jul.iface.Shutdownable

smartShutdown

public void smartShutdown()

shutdown

public void shutdown(long shutdownTimeout,
                     TimeUnit timeUnit)

forceShutdown

public void forceShutdown()

applyErrorHandling

public static Future applyErrorHandling(Future future,
                                        org.openbase.jul.iface.Processable<Exception,Void> errorProcessor,
                                        long timeout,
                                        TimeUnit timeUnit,
                                        ExecutorService executorService)
                                 throws CouldNotPerformException

This method applies an error handler to the given future object. In case the given timeout is expired or the future processing fails the error processor is processed with the occurred exception as argument. The receive a future should be submitted to any execution service or handled externally.

Parameters:

future - the future on which is the error processor is registered.

timeout - the timeout.

errorProcessor - the processable which handles thrown exceptions

timeUnit - the unit of the timeout.

executorService - the execution service to apply the handler.

Returns:

the future of the error handler.

Throws:

CouldNotPerformException - thrown by the errorProcessor

applyErrorHandling

public static Future applyErrorHandling(Future future,
                                        org.openbase.jul.iface.Processable<Exception,Void> errorProcessor,
                                        long timeout,
                                        TimeUnit timeUnit)
                                 throws CouldNotPerformException

This method applies an error handler to the given future object. In case the given timeout is expired or the future processing fails the error processor is processed with the occured exception as argument. The receive a future should be submitted to any execution service or handled externally.

Parameters:

future - the future on which is the error processor is registered.

timeout - the timeout.

errorProcessor - the processable which handles thrown exceptions

timeUnit - the unit of the timeout.

Returns:

the future of the error handler.

Throws:

CouldNotPerformException - thrown by the errorProcessor

allOf

public static <I,R> Future<R> allOf(ExecutorService executorService,
                                    Collection<I> inputList,
                                    org.openbase.jul.iface.Processable<I,Future<Void>> taskProcessor)

allOf

public static <I,R> Future<R> allOf(Collection<I> inputList,
                                    org.openbase.jul.iface.Processable<I,Future<R>> taskProcessor)
                             throws CouldNotPerformException

Throws:

CouldNotPerformException

allOf

public static <I,O,R> Future<R> allOf(Collection<I> inputList,
                                      org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor,
                                      org.openbase.jul.iface.Processable<I,Future<O>> taskProcessor)
                               throws CouldNotPerformException,
                                      InterruptedException

Throws:

CouldNotPerformException

InterruptedException

allOf

public static Future<Void> allOf(Future... futures)

allOf

public static <R> Future<R> allOf(Callable resultCallable,
                                  Future... futures)

allOfInclusiveResultFuture

public static <R> Future<R> allOfInclusiveResultFuture(Future<R> resultFuture,
                                                       Future... futures)

allOf

public static <R> Future<R> allOf(Collection<Future> futureCollection)

allOf

public static <R> Future<R> allOf(R returnValue,
                                  Collection<Future> futureCollection)

allOf

public static <R> Future<R> allOf(ExecutorService executorService,
                                  R returnValue,
                                  Collection<Future> futureCollection)

allOf

public static <I,O,R> Future<R> allOf(ExecutorService executorService,
                                      Collection<I> inputList,
                                      org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor,
                                      org.openbase.jul.iface.Processable<I,Future<O>> taskProcessor)

allOf

public static <R> Future<R> allOf(Callable<R> resultCallable,
                                  Collection<Future> futureCollection)

Method generates a new futures which represents all futures provided by the futureCollection. If all futures are successfully finished the outer future will be completed with the result provided by the resultCallable.

Type Parameters:

R - The result type of the outer future.

Parameters:

resultCallable - the callable which provides the result of the outer future.

futureCollection - the inner future collection.

Returns:

the outer future.

allOf

public static <R> Future<R> allOf(ExecutorService executorService,
                                  Callable<R> resultCallable,
                                  Collection<Future> futureCollection)

Method generates a new futures which represents all futures provided by the futureCollection. If all futures are successfully finished the outer future will be completed with the result provided by the resultCallable.

Type Parameters:

R - The result type of the outer future.

Parameters:

executorService - the execution service which is used for the outer future execution.

resultCallable - the callable which provides the result of the outer future.

futureCollection - the inner future collection.

Returns:

the outer future.

atLeastOne

public static <R> Future<R> atLeastOne(R returnValue,
                                       Collection<Future> futureCollection,
                                       long timeout,
                                       TimeUnit timeUnit)

atLeastOne

public static <R> Future<R> atLeastOne(Callable<R> resultCallable,
                                       Collection<Future> futureCollection,
                                       long timeout,
                                       TimeUnit timeUnit)

atLeastOne

public static <R> Future<R> atLeastOne(ExecutorService executorService,
                                       Callable<R> resultCallable,
                                       Collection<Future> futureCollection,
                                       long timeout,
                                       TimeUnit timeUnit)

Method generates a new futures which represents all futures provided by the futureCollection. If at least one future successfully finishes the outer future will be completed with the result provided by the resultCallable.

Type Parameters:

R - The result type of the outer future.

Parameters:

executorService - the execution service which is used for the outer future execution.

resultCallable - the callable which provides the result of the outer future.

futureCollection - the inner future collect

timeout -

timeUnit -

Returns:

the outer future.

allOf

public static <O,R> Future<R> allOf(org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor,
                                    Collection<Future<O>> futureCollection)

Method generates a new futures which represents all futures provided by the futureCollection.If all futures are successfully finished the outer future will be completed with the result provided by the resultProcessor. Node: For this method it's important that all futures provided by the future collection provide the same result type.

Type Parameters:

O - The output or result type of the futures provided by the future collection.

R - The result type of the outer future.

Parameters:

resultProcessor - the processor which provides the outer future result.

futureCollection - the inner future collection.

Returns:

the outer future.

allOf

public static <O,R> Future<R> allOf(ExecutorService executorService,
                                    org.openbase.jul.iface.Processable<Collection<Future<O>>,R> resultProcessor,
                                    Collection<Future<O>> futureCollection)

Method generates a new futures which represents all futures provided by the futureCollection. If all futures are successfully finished the outer future will be completed with the result provided by the resultProcessor. Node: For this method it's important that all futures provided by the future collection provide the same result type.

Type Parameters:

O - The output or result type of the futures provided by the future collection.

R - The result type of the outer future.

Parameters:

executorService - the execution service which is used for the outer future execution.

resultProcessor - the processor which provides the outer future result.

futureCollection - the inner future collection.

Returns:

the outer future.

buildFutureCollection

public static <I,O> Collection<Future<O>> buildFutureCollection(Collection<I> inputList,
                                                                org.openbase.jul.iface.Processable<I,Future<O>> taskProcessor)
                                                         throws CouldNotPerformException,
                                                                InterruptedException

Method builds a future collection with the given task processor. The input list is passed to the future build process so the input is available during the build.

Type Parameters:

I - The type of the input value used for the future build.

O - The type of the output value which the futures provide.

Parameters:

inputList - the input list which is needed for the build process.

taskProcessor - the task processor to build the futures.

Returns:

the collection of all builded future instances.

Throws:

CouldNotPerformException - is thrown if the future collection could not be generated.

InterruptedException - is thrown if the thread was externally interrupted.

toString

public String toString()

Simply prints the class name.

Overrides:

toString in class Object

Returns:

the class name of this instance.