ome.services.scheduler

Class ThreadPool

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ThreadPoolExecutor

ome.services.scheduler.ThreadPool

All Implemented Interfaces:

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

public class ThreadPool
extends java.util.concurrent.ThreadPoolExecutor

An internal implementation of ThreadPoolExecutor that additionally handles the submission of background(Callable) tasks at a lower priority and with more limited slots.

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

Constructor Summary

Constructors

Constructor and Description
ThreadPool() Default constructor.
ThreadPool(int minThreads, int maxThreads, long msTimeout, int backgroundThreads, long backgroundTimeout) This constructor creates a thread pool with an unbounded queue.

Method Summary

Modifier and Type	Method and Description
protected void	afterExecute(java.lang.Runnable r, java.lang.Throwable t) Standard ThreadPoolExecutor extension point which checks for the BackgroundFutureTask marker and releases a slot in the maxBackground Semaphore.
<T> java.util.concurrent.Future<T>	background(java.util.concurrent.Callable<T> callable) Schedule a task in one of the limited background slots.
java.util.concurrent.ExecutorService	getExecutor() Deprecated.
protected <T> java.util.concurrent.RunnableFuture<T>	newTaskFor(java.util.concurrent.Callable<T> callable) Overrides ThreadPoolExecutor to return our own instance of FutureTask so that we have a marker for when the background activity is completed in afterExecute(Runnable, Throwable).

Methods inherited from class java.util.concurrent.ThreadPoolExecutor

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

Methods inherited from class java.util.concurrent.AbstractExecutorService

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

Methods inherited from class java.lang.Object

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

Constructor Detail

ThreadPool

public ThreadPool()

Default constructor. Unlike the argument constructor, it effectively has no queue for tasks and will always create a new thread to accommodate new tasks. Background tasks are limited to 10.

ThreadPool

public ThreadPool(int minThreads,
                  int maxThreads,
                  long msTimeout,
                  int backgroundThreads,
                  long backgroundTimeout)

This constructor creates a thread pool with an unbounded queue. This means that minThreads will set the number of core threads, which is the maximum number of threads active at one time when an unbounded queue is used. This also means that maxThreads does nothing, since threads are created beyond the core pool size only when the queue is full. Additionally, by default core threads never time out, so msTimeout also does nothing. See the ThreadPoolExecutor docs for more information.

Parameters:

minThreads - Sets the core pool size which is also the MAX pool size

maxThreads - This does NOTHING

msTimeout - This does NOTHING

backgroundThreads - Parameter name is a bit misleading. It is the maximum number of background tasks that can be submitted (queued or running) at once. The background threads come from the same pool, which is limited to minThreads in size, so if minThreads is lower, that will control the maximum number of threads capable of running background tasks.

backgroundTimeout - If more than backgroundThreads tasks are queued or processing, this is how long a task will wait to be submitted before being dropped

Method Detail

getExecutor

@Deprecated
public java.util.concurrent.ExecutorService getExecutor()

Deprecated.

Returns this. Previously ThreadPool was not itself an ExecutorService and returned a delegate instead, most typically in a Spring configuration.

background

public <T> java.util.concurrent.Future<T> background(java.util.concurrent.Callable<T> callable)

Schedule a task in one of the limited background slots. If scheduling takes more than hour then the submission will be rejected. Otherwise, the task will run in the same thread pool as both USER and BACKGROUND tasks.

Parameters:

callable -

Returns:

a future for this task

newTaskFor

protected <T> java.util.concurrent.RunnableFuture<T> newTaskFor(java.util.concurrent.Callable<T> callable)

Overrides ThreadPoolExecutor to return our own instance of FutureTask so that we have a marker for when the background activity is completed in afterExecute(Runnable, Throwable). Overriding this method is somewhat non-standard.

Overrides:

newTaskFor in class java.util.concurrent.AbstractExecutorService

afterExecute

protected void afterExecute(java.lang.Runnable r,
                            java.lang.Throwable t)

Standard ThreadPoolExecutor extension point which checks for the BackgroundFutureTask marker and releases a slot in the maxBackground Semaphore.

Overrides:

afterExecute in class java.util.concurrent.ThreadPoolExecutor