java executor 源码_java Executor框架源代码

package java.util.concurrent;

/**

* An object that executes submitted {@link Runnable} tasks. This

* interface provides a way of decoupling task submission from the

* mechanics of how each task will be run, including details of thread

* use, scheduling, etc. An Executor is normally used

* instead of explicitly creating threads. For example, rather than

* invoking new Thread(new(RunnableTask())).start() for each

* of a set of tasks, you might use:

*

*

* Executor executor = anExecutor;

* executor.execute(new RunnableTask1());

* executor.execute(new RunnableTask2());

* ...

*

*

* However, the Executor interface does not strictly

* require that execution be asynchronous. In the simplest case, an

* executor can run the submitted task immediately in the caller's

* thread:

*

*

* class DirectExecutor implements Executor {

* public void execute(Runnable r) {

* r.run();

* }

* }

*

* More typically, tasks are executed in some thread other

* than the caller's thread. The executor below spawns a new thread

* for each task.

*

*

* class ThreadPerTaskExecutor implements Executor {

* public void execute(Runnable r) {

* new Thread(r).start();

* }

* }

*

* Many Executor implementations impose some sort of

* limitation on how and when tasks are scheduled. The executor below

* serializes the submission of tasks to a second executor,

* illustrating a composite executor.

*

*

 {@code

* class SerialExecutor implements Executor {

* final Queue tasks = new ArrayDeque();

* final Executor executor;

* Runnable active;

*

* SerialExecutor(Executor executor) {

* this.executor = executor;

* }

*

* public synchronized void execute(final Runnable r) {

* tasks.offer(new Runnable() {

* public void run() {

* try {

* r.run();

* } finally {

* scheduleNext();

* }

* }

* });

* if (active == null) {

* scheduleNext();

* }

* }

*

* protected synchronized void scheduleNext() {

* if ((active = tasks.poll()) != null) {

* executor.execute(active);

* }

* }

* }}

*

* The Executor implementations provided in this package

* implement {@link ExecutorService}, which is a more extensive

* interface. The {@link ThreadPoolExecutor} class provides an

* extensible thread pool implementation. The {@link Executors} class

* provides convenient factory methods for these Executors.

*

*

Memory consistency effects: Actions in a thread prior to

* submitting a {@code Runnable} object to an {@code Executor}

* happen-before

* its execution begins, perhaps in another thread.

*

* @since 1.5

* @author Doug Lea

*/

public interface Executor {

/**

* Executes the given command at some time in the future. The command

* may execute in a new thread, in a pooled thread, or in the calling

* thread, at the discretion of the Executor implementation.

*

* @param command the runnable task

* @throws RejectedExecutionException if this task cannot be

* accepted for execution.

* @throws NullPointerException if command is null

*/

void execute(Runnable command);

}