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