ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jdk7/java/util/concurrent/Executor.java

Comparing jsr166/src/jdk7/java/util/concurrent/Executor.java (file contents):
Revision 1.1 by dl, Sun Dec 16 20:55:15 2012 UTC vs.
Revision 1.5 by jsr166, Sun May 25 01:20:22 2014 UTC

#	Line 10 | Line 10 | package java.util.concurrent;
10		* An object that executes submitted {@link Runnable} tasks. This
11		* interface provides a way of decoupling task submission from the
12		* mechanics of how each task will be run, including details of thread
13	<	* use, scheduling, etc.  An <tt>Executor</tt> is normally used
13	>	* use, scheduling, etc.  An {@code Executor} is normally used
14		* instead of explicitly creating threads. For example, rather than
15	<	* invoking <tt>new Thread(new(RunnableTask())).start()</tt> for each
15	>	* invoking {@code new Thread(new(RunnableTask())).start()} for each
16		* of a set of tasks, you might use:
17		*
18		* <pre>
#	Line 22 | Line 22 | package java.util.concurrent;
22		* ...
23		* </pre>
24		*
25	<	* However, the <tt>Executor</tt> interface does not strictly
25	>	* However, the {@code Executor} interface does not strictly
26		* require that execution be asynchronous. In the simplest case, an
27		* executor can run the submitted task immediately in the caller's
28		* thread:
#	Line 45 | Line 45 | package java.util.concurrent;
45		*   }
46		* }}</pre>
47		*
48	<	* Many <tt>Executor</tt> implementations impose some sort of
48	>	* Many {@code Executor} implementations impose some sort of
49		* limitation on how and when tasks are scheduled.  The executor below
50		* serializes the submission of tasks to a second executor,
51		* illustrating a composite executor.
52		*
53		*  <pre> {@code
54		* class SerialExecutor implements Executor {
55	<	*   final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
55	>	*   final Queue<Runnable> tasks = new ArrayDeque<>();
56		*   final Executor executor;
57		*   Runnable active;
58		*
#	Line 61 | Line 61 | package java.util.concurrent;
61		*   }
62		*
63		*   public synchronized void execute(final Runnable r) {
64	<	*     tasks.offer(new Runnable() {
64	>	*     tasks.add(new Runnable() {
65		*       public void run() {
66		*         try {
67		*           r.run();
#	Line 82 | Line 82 | package java.util.concurrent;
82		*   }
83		* }}</pre>
84		*
85	<	* The <tt>Executor</tt> implementations provided in this package
85	>	* The {@code Executor} implementations provided in this package
86		* implement {@link ExecutorService}, which is a more extensive
87		* interface.  The {@link ThreadPoolExecutor} class provides an
88		* extensible thread pool implementation. The {@link Executors} class
#	Line 101 | Line 101 | public interface Executor {
101		/**
102		* Executes the given command at some time in the future.  The command
103		* may execute in a new thread, in a pooled thread, or in the calling
104	<	* thread, at the discretion of the <tt>Executor</tt> implementation.
104	>	* thread, at the discretion of the {@code Executor} implementation.
105		*
106		* @param command the runnable task
107		* @throws RejectedExecutionException if this task cannot be
108	<	* accepted for execution.
108	>	* accepted for execution
109		* @throws NullPointerException if command is null
110		*/
111		void execute(Runnable command);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines