org.jupnp

Class QueueingThreadPoolExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ThreadPoolExecutor

org.jupnp.QueueingThreadPoolExecutor

All Implemented Interfaces:

Executor, ExecutorService

public class QueueingThreadPoolExecutor
extends ThreadPoolExecutor

This is a thread pool executor service, which works as a developer would expect it to work. The default ThreadPoolExecutor does the following (see the official JavaDoc):

• If fewer than corePoolSize threads are running, the Executor always prefers adding a new thread rather than queuing.
• If corePoolSize or more threads are running, the Executor always prefers queuing a request rather than adding a new thread.
• If a request cannot be queued, a new thread is created unless this would exceed maximumPoolSize, in which case, the task will be rejected.

This class in contrast implements the following logic:

• corePoolSize is 1, so threads are only created on demand
• If the number of busy threads is smaller than the threadPoolSize, the Executor always prefers adding (or reusing) a thread rather than queuing it.
• If threadPoolSize threads are busy, new requests will be put in a FIFO queue and processed as soon as a thread becomes idle.
• The queue size is unbound, i.e. requests will never be rejected.
• Threads are terminated after being idle for at least 10 seconds.

Please note that this implementation (with its partially hard-coded settings) is specifically targeted for use on embedded devices without a high throughput. If you intend to use it for mass data processing on a server, you should definitely tweak those settings.

Author:

Kai Kreuzer - Initial contribution and API

Nested Class Summary

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

ThreadPoolExecutor.AbortPolicy, ThreadPoolExecutor.CallerRunsPolicy, ThreadPoolExecutor.DiscardOldestPolicy, ThreadPoolExecutor.DiscardPolicy

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	QueueingThreadPoolExecutor(String name, int threadPoolSize) Allows to subclass QueueingThreadPoolExecutor.

Method Summary

Modifier and Type	Method and Description
protected void	addToQueue(Runnable runnable) Adds a new task to the queue
protected void	afterExecute(Runnable r, Throwable t)
static QueueingThreadPoolExecutor	createInstance(String name, int threadPoolSize) Creates a new instance of QueueingThreadPoolExecutor
void	execute(Runnable command)
BlockingQueue<Runnable>	getQueue()
void	setRejectedExecutionHandler(RejectedExecutionHandler handler) This implementation does not allow setting a custom handler.

Methods inherited from class java.util.concurrent.ThreadPoolExecutor

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

Methods inherited from class java.util.concurrent.AbstractExecutorService

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

Methods inherited from class java.lang.Object

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

Constructor Detail

QueueingThreadPoolExecutor

protected QueueingThreadPoolExecutor(String name,
                                     int threadPoolSize)

Allows to subclass QueueingThreadPoolExecutor.

Method Detail

createInstance

public static QueueingThreadPoolExecutor createInstance(String name,
                                                        int threadPoolSize)

Creates a new instance of QueueingThreadPoolExecutor

Parameters:

name - the name of the thread pool, will be used as a prefix for the name of the threads

threadPoolSize - the maximum size of the pool

Returns:

the QueueingThreadPoolExecutor instance

addToQueue

protected void addToQueue(Runnable runnable)

Adds a new task to the queue

Parameters:

runnable - the task to add

afterExecute

protected void afterExecute(Runnable r,
                            Throwable t)

Overrides:

afterExecute in class ThreadPoolExecutor

setRejectedExecutionHandler

public void setRejectedExecutionHandler(RejectedExecutionHandler handler)

This implementation does not allow setting a custom handler.

Overrides:

setRejectedExecutionHandler in class ThreadPoolExecutor

Throws:

UnsupportedOperationException - if called.

getQueue

public BlockingQueue<Runnable> getQueue()

Overrides:

getQueue in class ThreadPoolExecutor

execute

public void execute(Runnable command)

Specified by:

execute in interface Executor

Overrides:

execute in class ThreadPoolExecutor