de.aristaflow.adept2.util.threading.executor

Class ObjectOneWorkExecutor<O>

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ThreadPoolExecutor

de.aristaflow.adept2.util.threading.AFThreadPoolExecutor

de.aristaflow.adept2.util.threading.CachedThreadPoolExecutor

de.aristaflow.adept2.util.threading.executor.AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

de.aristaflow.adept2.util.threading.executor.ObjectOneWorkExecutor<O>

Type Parameters:

O - The type of object for which work is registered.

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService

public class ObjectOneWorkExecutor<O>
extends AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

A one work executor allows for an arbitrary amount of objects having work, but only one piece of work is allowed for each object at a time. If work is added for an object that has pending work, the new work will be silently ignored and cancelled immediately. Instead of the completion of previous work this can also last until the next flush.
It is also possible to add new work that overrides (and cancel) previous pending work. This will not override running work.

As object-specific executor, the indexed objects are the same as the registered objects. The runtime data consists of a pair of runnables that are registered for the corresponding object. The first runnable is the one pending to be executed after the current work but before a flush. This work will be cancelled if flushing is with abortion. It will be null if there is no more work or if the work should block until the next flush. The second runnable is work which is added while a flush is pending. This is executed right after all pending flushs have been executed.
To prevent starvation, each piece of work will be executed by an arbitrary thread; work for the same object will only be executed by the same thread when shutting down.

Nested Class Summary

Nested classes/interfaces inherited from class java.util.concurrent.ThreadPoolExecutor

java.util.concurrent.ThreadPoolExecutor.AbortPolicy, java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy, java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy, java.util.concurrent.ThreadPoolExecutor.DiscardPolicy

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	blockUntilFlush Whether work should be blocked for each object until the next flush.
protected java.util.Collection<java.lang.Thread>	overridingWork The threads that are currently submitting or executing a piece of work that should override existing (pending) work.

Fields inherited from class de.aristaflow.adept2.util.threading.executor.AbstractObjectSpecificExecutor

abortCount, flushPending, logger, objects, shutdownPending

Fields inherited from class de.aristaflow.adept2.util.threading.CachedThreadPoolExecutor

fullSize, realCoreSize, realMaxSize, workSize

Fields inherited from class de.aristaflow.adept2.util.threading.AFThreadPoolExecutor

activeThreads, completedTasks, submittedTasks

Constructor Summary

Constructors

Constructor and Description
ObjectOneWorkExecutor(boolean blockUntilFlush, Adept2ThreadFactory threadFactory) Creates a new thread pool executor with an unlimited amount of threads and objects, accepting exactly one piece of work per object.
ObjectOneWorkExecutor(boolean blockUntilFlush, int corePoolSize, int maxPoolSize, boolean prestart, Adept2ThreadFactory threadFactory) Creates a new thread pool executor with the designated (maximum) amount of (core) threads (and unlimited objects), accepting exactly one piece of work per object.

Method Summary

Modifier and Type	Method and Description
protected ObjectRunnable<O,O>	addRunnable(O registeredObject, O indexObject, java.lang.Runnable task) Adds the designated runnable for the designated object and index object to this executor.
protected <T> Pair<java.util.concurrent.Future<T>,java.util.Map<O,Pair<java.lang.Runnable,java.lang.Runnable>>>	cancelAndFlush(boolean shutdownRequest, java.util.Map<O,Pair<java.lang.Runnable,java.lang.Runnable>> pending, java.util.concurrent.Callable<T> task, java.util.Collection<ObjectRunnable<O,O>> objectRunnables) Cancels the designated pending work (if appropriate), flushes (i. e. waits for or aborts the designated runnables) and executes the designated task.
protected void	clearAbortedPendingWork(boolean shutdownRequest) Removes all pending work that should be aborted for an aborting flush, that is, it removes the from the data structures, e. g.
void	executeOverride(O object, java.lang.Runnable task) Executes the designated task for the designated object and overrides pending work if this exists.
protected void	executeShutdown(java.lang.Runnable shutdown) Executes the designated shutdown task which contains a flush calling ThreadPoolExecutor.shutdown() without abortion.
protected O	getIndexObjectFor(O object) Gets the object used for managing and executing runnables within this executor.
protected java.util.List<java.lang.Runnable>	getOutstandingRunnables(java.util.Map<O,Pair<java.lang.Runnable,java.lang.Runnable>> outstandingWork) Gets a list of runnables which have not been executed based on the designated outstanding work.
protected void	restartPendingWork() Checks for whether there is work pending for after a restart.
<T> java.util.concurrent.Future<T>	submitOverride(O object, java.util.concurrent.Callable<T> task) Submits the designated task for the designated object and overrides existing pending work.
java.util.concurrent.Future<?>	submitOverride(O object, java.lang.Runnable task) Submits the designated task for the designated object and overrides existing pending work.

Methods inherited from class de.aristaflow.adept2.util.threading.executor.AbstractObjectSpecificExecutor

execute, flushAndExecute, flushAndExecuteUnchecked, isShutdown, restart, shutdown, shutdownNow, shutdownRunnableRun, submit, submit, submitAndFlush

Methods inherited from class de.aristaflow.adept2.util.threading.CachedThreadPoolExecutor

afterExecute, execute

Methods inherited from class de.aristaflow.adept2.util.threading.AFThreadPoolExecutor

beforeExecute, newTaskFor, newTaskFor, setLogExecuteCallStack, updateQueueLimit

Methods inherited from class java.util.concurrent.ThreadPoolExecutor

allowCoreThreadTimeOut, allowsCoreThreadTimeOut, awaitTermination, finalize, getActiveCount, getCompletedTaskCount, getCorePoolSize, getKeepAliveTime, getLargestPoolSize, getMaximumPoolSize, getPoolSize, getQueue, getRejectedExecutionHandler, getTaskCount, getThreadFactory, isTerminated, isTerminating, prestartAllCoreThreads, prestartCoreThread, purge, remove, setCorePoolSize, setKeepAliveTime, setMaximumPoolSize, setRejectedExecutionHandler, setThreadFactory, terminated, toString

Methods inherited from class java.util.concurrent.AbstractExecutorService

invokeAll, invokeAll, invokeAny, invokeAny, submit, submit, submit

Methods inherited from class java.lang.Object

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

Field Detail

blockUntilFlush

protected final boolean blockUntilFlush

Whether work should be blocked for each object until the next flush. Otherwise work is allowed as soon as the work of the object has started.

overridingWork

protected final java.util.Collection<java.lang.Thread> overridingWork

The threads that are currently submitting or executing a piece of work that should override existing (pending) work. Overriding needs to be considered within addRunnable(Object, Object, Runnable), using this collection avoids the need for an additional method parameter (which would require an ugly interface change).

Constructor Detail

ObjectOneWorkExecutor

public ObjectOneWorkExecutor(boolean blockUntilFlush,
                             Adept2ThreadFactory threadFactory)

Creates a new thread pool executor with an unlimited amount of threads and objects, accepting exactly one piece of work per object. It uses the designated thread factory for creating threads. The threads will stay idle for 60 seconds before they terminate.

Parameters:

blockUntilFlush - Whether work should be blocked for each object until the next flush. Otherwise work is allowed as soon as the work of the object has started.

threadFactory - The factory to use when the executor creates a new thread.

ObjectOneWorkExecutor

public ObjectOneWorkExecutor(boolean blockUntilFlush,
                             int corePoolSize,
                             int maxPoolSize,
                             boolean prestart,
                             Adept2ThreadFactory threadFactory)

Creates a new thread pool executor with the designated (maximum) amount of (core) threads (and unlimited objects), accepting exactly one piece of work per object. It uses the designated thread factory for creating threads. The threads will stay idle for 60 seconds before they terminate.

Parameters:

blockUntilFlush - Whether work should be blocked for each object until the next flush. Otherwise work is allowed as soon as the work of the object has started.

corePoolSize - The number of threads to keep in the pool, even if they are idle.

maxPoolSize - The maximum number of threads to allow in the pool.

prestart - Whether all core threads should be prestarted.

threadFactory - The factory to use when the executor creates a new thread.

Method Detail

executeOverride

public void executeOverride(O object,
                            java.lang.Runnable task)

Executes the designated task for the designated object and overrides pending work if this exists.

Parameters:

object - The object for which to execute the designated task.

task - The task which to execute.

Throws:

java.util.concurrent.RejectedExecutionException - if the executor has been shut down, a RejectedExecutionException will be thrown.

See Also:

AbstractObjectSpecificExecutor.execute(Object, Runnable)

submitOverride

public java.util.concurrent.Future<?> submitOverride(O object,
                                                     java.lang.Runnable task)

Submits the designated task for the designated object and overrides existing pending work.

Parameters:

object - The object for which to execute the designated task.

task - The task which to execute.

Returns:

A Future representing pending completion of the task

Throws:

java.util.concurrent.RejectedExecutionException - if the executor has been shut down, a RejectedExecutionException will be thrown.

See Also:

AbstractObjectSpecificExecutor.submit(Object, Runnable)

submitOverride

public <T> java.util.concurrent.Future<T> submitOverride(O object,
                                                         java.util.concurrent.Callable<T> task)

Submits the designated task for the designated object and overrides existing pending work.

Parameters:

object - The object for which to execute the designated task.

task - The task which to execute.

Returns:

A Future representing pending completion of the task

Throws:

java.util.concurrent.RejectedExecutionException - if the executor has been shut down, a RejectedExecutionException will be thrown.

See Also:

AbstractObjectSpecificExecutor.submit(Object, Callable)

getIndexObjectFor

protected O getIndexObjectFor(O object)

Description copied from class: AbstractObjectSpecificExecutor

Gets the object used for managing and executing runnables within this executor.

Specified by:

getIndexObjectFor in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

Parameters:

object - The object for which a runnable is registered.

Returns:

The object used for managing and executing runnables (registered for the designated object) within this executor.

addRunnable

protected ObjectRunnable<O,O> addRunnable(O registeredObject,
                                          O indexObject,
                                          java.lang.Runnable task)

Description copied from class: AbstractObjectSpecificExecutor

Adds the designated runnable for the designated object and index object to this executor.
Implementations may store the work internally for later execution or assign it to an already existing active element (usually a thread). If they need a new active element for the designated runnable, they have to return a new runnable which will then be added to this executor using the normal CachedThreadPoolExecutor.execute(Runnable). If they return null, they have to assign the runnable to an active element eventually and arbitrarily.

The caller has the lock on objects.

Specified by:

addRunnable in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

Parameters:

registeredObject - The object for which this runnable has been registered.

indexObject - The object with which this runnable is managed and executed within the corresponding object-specific executor service.

task - The task which to execute.

Returns:

A runnable which to add to the executor so that this gets a new active element (thread). This will be handled via CachedThreadPoolExecutor.execute(Runnable), which means the runnable will be executed independently from other work and a new thread may be started for it.

clearAbortedPendingWork

protected void clearAbortedPendingWork(boolean shutdownRequest)

Removes all pending work that should be aborted for an aborting flush, that is, it removes the from the data structures, e. g. objects. This method only affects data structures, it does not affect any executed work. The caller will take care of this shortly.

The caller has the lock on objects. Only removes the entries which do not have work pending for after a flush in case this is no shutdown request. Otherwise all objects and all work will be removed.

Specified by:

clearAbortedPendingWork in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

Parameters:

shutdownRequest - Whether this flush is caused by a AbstractObjectSpecificExecutor.shutdownNow(). In this case all work has to be aborted, even the work pending after a flush.

cancelAndFlush

protected <T> Pair<java.util.concurrent.Future<T>,java.util.Map<O,Pair<java.lang.Runnable,java.lang.Runnable>>> cancelAndFlush(boolean shutdownRequest,
                                                                                                                               java.util.Map<O,Pair<java.lang.Runnable,java.lang.Runnable>> pending,
                                                                                                                               java.util.concurrent.Callable<T> task,
                                                                                                                               java.util.Collection<ObjectRunnable<O,O>> objectRunnables)

Description copied from class: AbstractObjectSpecificExecutor

Cancels the designated pending work (if appropriate), flushes (i. e. waits for or aborts the designated runnables) and executes the designated task.

The caller has the lock on objects.

Specified by:

cancelAndFlush in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

Parameters:

shutdownRequest - Whether this flush is caused by a AbstractObjectSpecificExecutor.shutdownNow(). In this case all work has to be aborted, even the work pending after a flush.

pending - The pending work that will not be executed due to abort or null if running work should not be aborted.

task - The task which to execute without any object work running.

objectRunnables - The currently running work. This will either be aborted or awaited for flushing.

Returns:

A pair containing the future representing the designated task and as second element either null in case no abortion is requested otherwise the managed objects and the runtime data of the aborted work. Note that the runtime data may contain work that is not cancelled by the flush. This depends on the runtime data.

restartPendingWork

protected void restartPendingWork()

Checks for whether there is work pending for after a restart. If so, makes this the current work and creates a new ObjectRunnable for executing this pending work.

Overrides:

restartPendingWork in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

executeShutdown

protected void executeShutdown(java.lang.Runnable shutdown)

Description copied from class: AbstractObjectSpecificExecutor

Executes the designated shutdown task which contains a flush calling ThreadPoolExecutor.shutdown() without abortion.
This method is only called if there is pending work. So the implementation may decide on how and when to execute the shutdown runnable.

The caller has the lock on objects.

Specified by:

executeShutdown in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

Parameters:

shutdown - The task which to perform to shutdown.

getOutstandingRunnables

protected java.util.List<java.lang.Runnable> getOutstandingRunnables(java.util.Map<O,Pair<java.lang.Runnable,java.lang.Runnable>> outstandingWork)

Description copied from class: AbstractObjectSpecificExecutor

Gets a list of runnables which have not been executed based on the designated outstanding work.
This method will be called after an immediate shutdown which aborts pending work. Depending on the implementation, the designated runtime data may contain runnables which have not been executed and should therefore be returned to conform to the interface of an executor service.
The caller does not have the lock on objects.

Specified by:

getOutstandingRunnables in class AbstractObjectSpecificExecutor<O,O,Pair<java.lang.Runnable,java.lang.Runnable>>

Parameters:

outstandingWork - The pending work that has been aborted due to the immediate shutdown.

Returns:

A list of runnables stemming from the designated outstanding work.