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 
36 package 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  */
124 public 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      */
execute(Runnable command)136     void execute(Runnable command);
137 }
138