de.cismet.commons.concurrency

Class CismetExecutors

java.lang.Object

de.cismet.commons.concurrency.CismetExecutors

public final class CismetExecutors
extends Object

This class is a copy of Executors except that the ExecutorServicees created by this class will inform an Thread.UncaughtExceptionHandler in case of a call to any of the ExecutorService' submit operations. The default Executors will not inform an UncaughtExceptionHandler because it assumes that a 'submitter' is responsible for calling Future.get() to retrieve the execution result which results in an ExecutionException in case of an error during execution. However, this may result in uncaught and thus 'invisible' exceptions and hence it gets very hard to trace errors if the get() operation will never be called, e.g. because the Future is not directly used by the 'submitter' but delegated to another operation or propagated up the call-stack as a return value, etc.

However, this class can provide an additional type of ExecutorService: The 'CachedLimitedThreadPool': It behaves like an ordinary 'CachedThreadPool' thus increasing and shrinking in size with respect to the current workload but unlike the 'CachedThreadPool' it can get full, too, similar to the 'FixedThreadPool'.

NOTE: ScheduledExecutorService not supported yet, but will be added soon.

IMPORTANT: Do not use any of these ExecutorServices if you are not sure if an UncaughtExceptionHandler may somehow interfere with the handling that will be done in case of an ExecutionException! Also keep in mind that it may occur that an exception is handled twice: via get() or the resulting ExecutionException, respectively, if called at all and via the UncaughtExceptionHandler if registered.

Version:

1.0

Author:

martin.scholl@cismet.de

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CismetExecutors.UEHThreadPoolExecutor Extension of the ThreadPoolExecutor that keeps track of the executed tasks and informs the Thread.UncaughtExceptionHandler associated with the executing thread in case of an exception during task execution.

Method Summary

Modifier and Type	Method and Description
static ExecutorService	newCachedLimitedThreadPool(int maxThreads, String prefix) Calls newCachedLimitedThreadPool(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler) with a null RejectedExecutionHandler and a ThreadFactory that is created using the prefix parameter as name of the ThreadFactory.
static ExecutorService	newCachedLimitedThreadPool(int maxThreads, ThreadFactory threadFactory) Calls newCachedLimitedThreadPool(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler) with a null RejectedExecutionHandler.
static ExecutorService	newCachedLimitedThreadPool(int maxThreads, ThreadFactory threadFactory, RejectedExecutionHandler rejectHandler) Creates a new ExecutorService that is dynamic like a CachedThreadPool but has an upper bound of threads executed in parallel.
static ExecutorService	newCachedThreadPool()
static ExecutorService	newCachedThreadPool(ThreadFactory threadFactory)
static ExecutorService	newFixedThreadPool(int nThreads)
static ExecutorService	newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
static ExecutorService	newSingleThreadExecutor()
static ExecutorService	newSingleThreadExecutor(ThreadFactory threadFactory)

Methods inherited from class java.lang.Object

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

Method Detail

newCachedLimitedThreadPool

public static ExecutorService newCachedLimitedThreadPool(int maxThreads,
                                                         String prefix)

Calls newCachedLimitedThreadPool(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler) with a null RejectedExecutionHandler and a ThreadFactory that is created using the prefix parameter as name of the ThreadFactory.

Parameters:

maxThreads - max amount of threads this ExecutorService will ever create

prefix - prefix used for the generation of the ThreadFactory

Returns:

the new ExecutorService

See Also:

newCachedLimitedThreadPool(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler)

newCachedLimitedThreadPool

public static ExecutorService newCachedLimitedThreadPool(int maxThreads,
                                                         ThreadFactory threadFactory)

Calls newCachedLimitedThreadPool(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler) with a null RejectedExecutionHandler.

Parameters:

maxThreads - max amount of threads this ExecutorService will ever create

threadFactory - the ThreadFactory that will be responsible for the creation of new threads

Returns:

the new ExecutorService

See Also:

newCachedLimitedThreadPool(int, java.util.concurrent.ThreadFactory, java.util.concurrent.RejectedExecutionHandler)

newCachedLimitedThreadPool

public static ExecutorService newCachedLimitedThreadPool(int maxThreads,
                                                         ThreadFactory threadFactory,
                                                         RejectedExecutionHandler rejectHandler)

Creates a new ExecutorService that is dynamic like a CachedThreadPool but has an upper bound of threads executed in parallel. The ExecutorService has the following properties:

• a minimum of 0 threads if there are no tasks
• a maximum of maxThreads
• a maximum of (maxThreads + 1) * 2 / 3 tasks queued for execution
• threads will die after 180 seconds if they are idle
• an ThreadPoolExecutor.AbortPolicy as RejectedExecutionHandler if the given handler is null

This means that this thread pool will not accept more than maxThreads + ((maxThreads + 1) * 2 / 3) at once for execution. Any supernumerous threads are rejected! By default the AbortPolicy kicks in then which means that an RejectedExecutionException is thrown.

Parameters:

maxThreads - max amount of threads this ExecutorService will ever create

threadFactory - the ThreadFactory that will be responsible for the creation of new threads

rejectHandler - the RejectedExecutionHandler that will handle rejected executions, the AbortPolicy by default.

Returns:

the new ExecutorService

See Also:

ThreadPoolExecutor

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads)

See Also:

Executors.newFixedThreadPool(int)

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads,
                                                 ThreadFactory threadFactory)

See Also:

Executors.newFixedThreadPool(int, java.util.concurrent.ThreadFactory)

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor()

See Also:

Executors.newSingleThreadExecutor()

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

See Also:

Executors.newSingleThreadExecutor(java.util.concurrent.ThreadFactory)

newCachedThreadPool

public static ExecutorService newCachedThreadPool()

See Also:

Executors.newCachedThreadPool()

newCachedThreadPool

public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

See Also:

Executors.newCachedThreadPool(java.util.concurrent.ThreadFactory)