/*
* Written by Doug Lea with assistance from members of JCP JSR-166
* Expert Group and released to the public domain. Use, modify, and
* redistribute this code in any way without acknowledgement.
*/
package java.util.concurrent;
import java.util.List;
import java.security.PrivilegedAction;
import java.security.PrivilegedExceptionAction;
/**
* An Executor that provides methods to manage termination
* and those that can produce a {@link Future} for tracking
* progress of one or more asynchronous tasks.
* An ExecutorService can be shut down, which will cause it
* to stop accepting new tasks. After being shut down, the executor
* will eventually terminate, at which point no tasks are actively
* executing, no tasks are awaiting execution, and no new tasks can be
* submitted.
*
*
The {@link Executors} class provides factory methods for the
* executor services provided in this package.
*
* @since 1.5
* @author Doug Lea
*/
public interface ExecutorService extends Executor {
/**
* Submits a Runnable task for execution and returns a Future
* representing that task.
*
* @param task the task to submit
* @param result the result to return upon completion
* If you do not need a particular result, consider using Boolean.TRUE .
* @return a Future representing pending completion of the task,
* and whose get() method will return the given value
* upon completion
* @throws RejectedExecutionException if task cannot be scheduled
* for execution
*/
Future submit(Runnable task, T result);
/**
* Submits a value-returning task for execution and returns a Future
* representing the pending results of the task.
*
* @param task the task to submit
* @return a Future representing pending completion of the task
* @throws RejectedExecutionException if task cannot be scheduled
* for execution
*/
Future submit(Callable task);
/**
* Executes a Runnable task and blocks until it completes normally
* or throws an exception.
*
* @param task the task to submit
* @throws RejectedExecutionException if task cannot be scheduled
* for execution
* @throws ExecutionException if the task encountered an exception
* while executing
*/
void invoke(Runnable task) throws ExecutionException, InterruptedException;
/**
* Executes a value-returning task and blocks until it returns a
* value or throws an exception.
*
* @param task the task to submit
* @return a Future representing pending completion of the task
* @throws RejectedExecutionException if task cannot be scheduled
* for execution
* @throws InterruptedException if interrupted while waiting for
* completion
* @throws ExecutionException if the task encountered an exception
* while executing
*/
T invoke(Callable task) throws ExecutionException, InterruptedException;
/**
* Submits a privileged action for execution under the current
* access control context and returns a Future representing the
* pending result object of that action.
*
* @param action the action to submit
* @return a Future representing pending completion of the action
* @throws RejectedExecutionException if action cannot be scheduled
* for execution
*/
Future submit(PrivilegedAction action);
/**
* Submits a privileged exception action for execution under the current
* access control context and returns a Future representing the pending
* result object of that action.
*
* @param action the action to submit
* @return a Future representing pending completion of the action
* @throws RejectedExecutionException if action cannot be scheduled
* for execution
*/
Future submit(PrivilegedExceptionAction action);
/**
* Initiates an orderly shutdown in which previously submitted
* tasks are executed, but no new tasks will be
* accepted. Invocation has no additional effect if already shut
* down.
*
*/
void shutdown();
/**
* Attempts to stop all actively executing tasks, halts the
* processing of waiting tasks, and returns a list of the tasks that were
* awaiting execution.
*
* There are no guarantees beyond best-effort attempts to stop
* processing actively executing tasks. For example, typical
* implementations will cancel via {@link Thread#interrupt}, so if any
* tasks mask or fail to respond to interrupts, they may never terminate.
*
* @return list of tasks that never commenced execution
*/
List shutdownNow();
/**
* Returns true if this executor has been shut down.
*
* @return true if this executor has been shut down
*/
boolean isShutdown();
/**
* Returns true if all tasks have completed following shut down.
* Note that isTerminated is never true unless
* either shutdown or shutdownNow was called first.
*
* @return true if all tasks have completed following shut down
*/
boolean isTerminated();
/**
* Blocks until all tasks have completed execution after a shutdown
* request, or the timeout occurs, or the current thread is
* interrupted, whichever happens first.
*
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @return true if this executor terminated and false
* if the timeout elapsed before termination
* @throws InterruptedException if interrupted while waiting
*/
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning when at
* least one of them has completed.
* Upon return, tasks that have not completed are cancelled.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @param result value for each task to return upon completion.
* If you do not need a particular result, consider using Boolean.TRUE .
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list. If the task list is
* non-empty, at least one element of this list is known to have
* completed. Other tasks may or may not have also completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks or any of its elements are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAny(List tasks, T result)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning when at
* least one of them has completed or the given timeout expires.
* Upon return, tasks that have not completed are cancelled.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @param result value for each task to return upon completion.
* If you do not need a particular result, consider using Boolean.TRUE .
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list. If the task list is
* non-empty and the operation did not time out, at least one
* element of this list is known to have completed. Other tasks
* may or may not have also completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks, any or its elements, or unit are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAny(List tasks, T result,
long timeout, TimeUnit unit)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning when
* all of them complete.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @param result value for each task to return upon completion.
* If you do not need a particular result, consider using Boolean.TRUE .
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list, each of which has
* completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks or any of its elements are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAll(List tasks, T result)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning normally
* when all complete or the given timeout expires, whichever
* happens first.
* Upon return, tasks that have not completed are cancelled.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @param result value for each task to return upon completion.
* If you do not need a particular result, consider using Boolean.TRUE .
* @param timeout the maximum time to wait
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list. If the operation did
* not time out, each task will have completed. If it did time
* out, some of these tasks will not have completed.
* @param unit the time unit of the timeout argument
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks, any or its elements, or unit are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAll(List tasks, T result,
long timeout, TimeUnit unit)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning when at
* least one of them has completed.
* Upon return, tasks that have not completed are cancelled.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list. If the task list is
* non-empty, at least one task on this list is known to have
* completed. Other tasks may or may not have also completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks or any of its elements are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAny(List> tasks)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning when at
* least one of them has completed or the given timeout expires.
* Upon return, tasks that have not completed are cancelled.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list. If the task list is
* non-empty and the operation did not time out, at least one task
* on this list is known to have completed. Other tasks may or may
* not have also completed. If the operation timed out, none of
* the tasks will have completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks, any or its elements, or unit are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAny(List> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning their results
* when all complete.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list, each of which has
* completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks or any of its elements are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAll(List> tasks)
throws InterruptedException;
/**
* Arranges for execution of the given tasks, returning their results
* when all complete or the timeout expires, whichever happens first.
* Upon return, tasks that have not completed are cancelled.
* Note that a completed task could have
* terminated either normally or by throwing an exception.
* @param tasks the collection of tasks
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @return A list of Futures representing the tasks, in the same
* sequential order as the given task list. If the operation did
* not time out, each task will have completed. If it did time
* out, some of thiese tasks will not have completed.
* @throws InterruptedException if interrupted while waiting, in
* which case unfinished tasks are cancelled.
* @throws NullPointerException if tasks, any or its elements, or
* unit are null
* @throws RejectedExecutionException if any task cannot be scheduled
* for execution
*/
List> invokeAll(List> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
}