This utility
class defines static factory methods for creating
ExecutorService and
ScheduledExecutorService objects. Each of the
factory methods has a variant that allows you to explicitly specify a
ThreadFactory. newSingleThreadExecutor(
) returns an ExecutorService that uses a
single thread and an unbounded queue of waiting tasks.
newFixedThreadPool( ) returns an
ExecutorService that uses a thread pool with the
specified number of threads and an unbounded queue.
newCachedThreadPool( ) returns an
ExecutorService that does not queue tasks but
instead creates as many threads as are needed. When a task
terminates, its thread is cached for reuse. Cached threads are
allowed to terminate if they remain unused for 60 seconds.
newSingleThreadScheduledExecutor( ) returns a
ScheduledExecutorService that uses a single thread
for running tasks. newScheduledThreadPool( )
returns a ScheduledExecutorService that uses a
thread pool of the specified size.
The factory methods of this class typically return instances of
ThreadPoolExecutor and
ScheduledThreadPoolExecutor. If the returned
objects are cast to these implementing types, they can be configured
(to change the thread pool size, for example). If you want to prevent
this from happening, use the unconfigurableExecutorService(
) and unconfigurableScheduledExecutorService(
) methods to obtain wrapper objects that implement only the
ExecutorService and
ScheduledExecutorService methods and do not permit
configuration.
Other methods of this class include callable( ),
which returns a Callable object wrapped around a
Runnable and an optional result, and
defaultThreadFactory( ), which returns a basic
ThreadFactory object. Executors also define
methods related to access control and the Java security system. A
variant of the callable( ) method wraps a
Callable around a
java.security.PrivilegedAction.
privilegedCallable( ) is intended to be invoked
from within a PrivilegedAction being run with
AccessController.doPrivileged( ). When passed a
Callable in this way, it returns a new
Callable that can be used later to invoke the
original callable in a privileged access control context, granting it
permissions that it would not otherwise have.
public class
Executors {
// No Constructor
// Public Class Methods
public static Callable<Object>
callable (java.security.PrivilegedAction
action );
public static Callable<Object>
callable (Runnable
task );
public static Callable<Object>
callable (java.security.PrivilegedExceptionAction
action );
public static <T> Callable<T>
callable (Runnable
task , T
result );
public static ThreadFactory
defaultThreadFactory ( );
public static ExecutorService
newCachedThreadPool ( );
public static ExecutorService
newCachedThreadPool (ThreadFactory
threadFactory );
public static ExecutorService
newFixedThreadPool (int
nThreads );
public static ExecutorService
newFixedThreadPool (int
nThreads , ThreadFactory
threadFactory );
public static ScheduledExecutorService
newScheduledThreadPool (int
corePoolSize );
public static ScheduledExecutorService
newScheduledThreadPool (int
corePoolSize ,
ThreadFactory
threadFactory );
public static ExecutorService
newSingleThreadExecutor ( );
public static ExecutorService
newSingleThreadExecutor (ThreadFactory
threadFactory );
public static ScheduledExecutorService
newSingleThreadScheduledExecutor ( );
public static ScheduledExecutorService
newSingleThreadScheduledExecutor (ThreadFactory
threadFactory );
public static <T> Callable<T>
privilegedCallable (Callable<T>
callable );
public static <T> Callable<T>
privilegedCallableUsingCurrentClassLoader
(Callable<T>
callable );
public static ThreadFactory
privilegedThreadFactory ( );
public static ExecutorService
unconfigurableExecutorService (ExecutorService
executor );
public static ScheduledExecutorService
unconfigurableScheduledExecutorService
(ScheduledExecutorService
executor );
}