1/*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation.  Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25/*
26 * This file is available under and governed by the GNU General Public
27 * License version 2 only, as published by the Free Software Foundation.
28 * However, the following notice accompanied the original version of this
29 * file:
30 *
31 * Written by Doug Lea with assistance from members of JCP JSR-166
32 * Expert Group and released to the public domain, as explained at
33 * http://creativecommons.org/publicdomain/zero/1.0/
34 */
35
36package java.util.concurrent;
37
38/**
39 * An object that executes submitted {@link Runnable} tasks. This
40 * interface provides a way of decoupling task submission from the
41 * mechanics of how each task will be run, including details of thread
42 * use, scheduling, etc.  An {@code Executor} is normally used
43 * instead of explicitly creating threads. For example, rather than
44 * invoking {@code new Thread(new RunnableTask()).start()} for each
45 * of a set of tasks, you might use:
46 *
47 * <pre> {@code
48 * Executor executor = anExecutor();
49 * executor.execute(new RunnableTask1());
50 * executor.execute(new RunnableTask2());
51 * ...}</pre>
52 *
53 * However, the {@code Executor} interface does not strictly require
54 * that execution be asynchronous. In the simplest case, an executor
55 * can run the submitted task immediately in the caller's thread:
56 *
57 * <pre> {@code
58 * class DirectExecutor implements Executor {
59 *   public void execute(Runnable r) {
60 *     r.run();
61 *   }
62 * }}</pre>
63 *
64 * More typically, tasks are executed in some thread other than the
65 * caller's thread.  The executor below spawns a new thread for each
66 * task.
67 *
68 * <pre> {@code
69 * class ThreadPerTaskExecutor implements Executor {
70 *   public void execute(Runnable r) {
71 *     new Thread(r).start();
72 *   }
73 * }}</pre>
74 *
75 * Many {@code Executor} implementations impose some sort of
76 * limitation on how and when tasks are scheduled.  The executor below
77 * serializes the submission of tasks to a second executor,
78 * illustrating a composite executor.
79 *
80 * <pre> {@code
81 * class SerialExecutor implements Executor {
82 *   final Queue<Runnable> tasks = new ArrayDeque<>();
83 *   final Executor executor;
84 *   Runnable active;
85 *
86 *   SerialExecutor(Executor executor) {
87 *     this.executor = executor;
88 *   }
89 *
90 *   public synchronized void execute(Runnable r) {
91 *     tasks.add(() -> {
92 *       try {
93 *         r.run();
94 *       } finally {
95 *         scheduleNext();
96 *       }
97 *     });
98 *     if (active == null) {
99 *       scheduleNext();
100 *     }
101 *   }
102 *
103 *   protected synchronized void scheduleNext() {
104 *     if ((active = tasks.poll()) != null) {
105 *       executor.execute(active);
106 *     }
107 *   }
108 * }}</pre>
109 *
110 * The {@code Executor} implementations provided in this package
111 * implement {@link ExecutorService}, which is a more extensive
112 * interface.  The {@link ThreadPoolExecutor} class provides an
113 * extensible thread pool implementation. The {@link Executors} class
114 * provides convenient factory methods for these Executors.
115 *
116 * <p>Memory consistency effects: Actions in a thread prior to
117 * submitting a {@code Runnable} object to an {@code Executor}
118 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
119 * its execution begins, perhaps in another thread.
120 *
121 * @since 1.5
122 * @author Doug Lea
123 */
124public interface Executor {
125
126    /**
127     * Executes the given command at some time in the future.  The command
128     * may execute in a new thread, in a pooled thread, or in the calling
129     * thread, at the discretion of the {@code Executor} implementation.
130     *
131     * @param command the runnable task
132     * @throws RejectedExecutionException if this task cannot be
133     * accepted for execution
134     * @throws NullPointerException if command is null
135     */
136    void execute(Runnable command);
137}
138