org.apache.river.thread

Class ThreadPool

java.lang.Object

org.apache.river.thread.ThreadPool

All Implemented Interfaces:

java.util.concurrent.Executor

final class ThreadPool
extends Object
implements Executor, java.util.concurrent.Executor

ThreadPool is a simple thread pool implementation of the Executor interface. A new task is always given to an idle thread, if one is available; otherwise, a new thread is always created. There is no minimum warm thread count, nor is there a maximum thread count (tasks are never queued unless there are sufficient idle threads to execute them). New threads are created as daemon threads in the thread group that was passed to the ThreadPool instance's constructor. Each thread's name is the prefix NewThreadAction.NAME_PREFIX followed by the name of the task it is currently executing, or "Idle" if it is currently idle.

This implementation uses the Logger named org.apache.river.thread.ThreadPool to log information at the following levels:

Level	Description
WARNING	uncaught exception in worker thread

Author:

Sun Microsystems, Inc.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	ThreadPool.Task Task simply encapsulates a task's Runnable object with its name.
private static class	ThreadPool.TPThreadFactory Thread stack size hint given to jvm to minimise memory consumption as this executor can create many threads, tasks executed are relatively simple and don't need much memory.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.concurrent.ExecutorService	es
private static Logger	logger
private boolean	shutdown This Executor is used by JERI (and other Jini implementation classes) to delegate tasks to, the intent is to hand off to a new thread immediately, however: 1.

Constructor Summary

Constructors

Modifier	Constructor and Description
private	ThreadPool(java.util.concurrent.ExecutorService es)
(package private)	ThreadPool(ThreadGroup threadGroup)

Method Summary

Modifier and Type	Method and Description
void	execute(Runnable command)
void	execute(Runnable runnable, String name) Executes the given Runnable action asynchronously in some thread.
private Thread	shutdownHook()

Methods inherited from class java.lang.Object

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

Field Detail

logger

private static final Logger logger

shutdown

private volatile boolean shutdown

This Executor is used by JERI (and other Jini implementation classes) to delegate tasks to, the intent is to hand off to a new thread immediately, however: 1. When ThreadPool creates threads too aggressively, stress tests in the qa suite create too many threads and hang because tasks that need to respond within a required time cannot. 2. Conversely when thread creation takes too long, Javaspace tests that rely on event propagation to cancel a LeasedResource find that lease still available after lease expiry. 3. If no threads are available when JERI needs to start a Mux connection, then a mux writer cannot initiate a client connection, for this reason, a new thread must be created if no waiting threads are available to the caller. ThreadPool must degrade gracefully when a system is under significant load, but it must also execute tasks as soon as possible. ThreadGroup is a construct originally intended for applet isolation, however it was never really successful, AccessControlContext is a much more effective way of controlling privilege. We should consider changing this to ensure that each task is executed in the AccessControlContext of the calling thread, to avoid privilege escalation.

es

private final java.util.concurrent.ExecutorService es

Constructor Detail

ThreadPool

ThreadPool(ThreadGroup threadGroup)

ThreadPool

private ThreadPool(java.util.concurrent.ExecutorService es)

Method Detail

shutdownHook

private Thread shutdownHook()

execute

public void execute(Runnable runnable,
                    String name)
             throws java.util.concurrent.RejectedExecutionException

Description copied from interface: Executor

Executes the given Runnable action asynchronously in some thread. The implementation may create a new thread to execute the action, or it may execute the action in an existing thread. The execution of a given action must not be delayed indefinitely in order to complete execution of a different action passed to a different invocation of this method. In other words, the implementation must assume that there may be arbitrary dependencies between actions passed to this method, so it needs to be careful to avoid potential deadlock by delaying execution of one action indefinitely until another completes. Also, this method itself must not block, because it may be invoked by code that is serially processing data to produce multiple such arbitrarily-dependent actions that need to be executed.

Parameters:

runnable - the Runnable action to execute

name - string to include in the name of the thread used to execute the action

Throws:

java.util.concurrent.RejectedExecutionException

execute

public void execute(Runnable command)

Specified by:

execute in interface java.util.concurrent.Executor