src/share/classes/java/util/concurrent/Executor.java

Print this page




  62  *         r.run();
  63  *     }
  64  * }</pre>
  65  *
  66  * More typically, tasks are executed in some thread other
  67  * than the caller's thread.  The executor below spawns a new thread
  68  * for each task.
  69  *
  70  * <pre>
  71  * class ThreadPerTaskExecutor implements Executor {
  72  *     public void execute(Runnable r) {
  73  *         new Thread(r).start();
  74  *     }
  75  * }</pre>
  76  *
  77  * Many <tt>Executor</tt> implementations impose some sort of
  78  * limitation on how and when tasks are scheduled.  The executor below
  79  * serializes the submission of tasks to a second executor,
  80  * illustrating a composite executor.
  81  *
  82  * <pre>
  83  * class SerialExecutor implements Executor {
  84  *     final Queue&lt;Runnable&gt; tasks = new ArrayDeque&lt;Runnable&gt;();
  85  *     final Executor executor;
  86  *     Runnable active;
  87  *
  88  *     SerialExecutor(Executor executor) {
  89  *         this.executor = executor;
  90  *     }
  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();
 104  *         }
 105  *     }
 106  *
 107  *     protected synchronized void scheduleNext() {
 108  *         if ((active = tasks.poll()) != null) {
 109  *             executor.execute(active);
 110  *         }
 111  *     }
 112  * }</pre>
 113  *
 114  * The <tt>Executor</tt> implementations provided in this package
 115  * implement {@link ExecutorService}, which is a more extensive
 116  * interface.  The {@link ThreadPoolExecutor} class provides an
 117  * extensible thread pool implementation. The {@link Executors} class
 118  * provides convenient factory methods for these Executors.
 119  *
 120  * <p>Memory consistency effects: Actions in a thread prior to
 121  * submitting a {@code Runnable} object to an {@code Executor}
 122  * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
 123  * its execution begins, perhaps in another thread.
 124  *
 125  * @since 1.5
 126  * @author Doug Lea
 127  */
 128 public interface Executor {
 129 
 130     /**
 131      * Executes the given command at some time in the future.  The command
 132      * may execute in a new thread, in a pooled thread, or in the calling


  62  *         r.run();
  63  *     }
  64  * }</pre>
  65  *
  66  * More typically, tasks are executed in some thread other
  67  * than the caller's thread.  The executor below spawns a new thread
  68  * for each task.
  69  *
  70  * <pre>
  71  * class ThreadPerTaskExecutor implements Executor {
  72  *     public void execute(Runnable r) {
  73  *         new Thread(r).start();
  74  *     }
  75  * }</pre>
  76  *
  77  * Many <tt>Executor</tt> implementations impose some sort of
  78  * limitation on how and when tasks are scheduled.  The executor below
  79  * serializes the submission of tasks to a second executor,
  80  * illustrating a composite executor.
  81  *
  82  *  <pre> {@code
  83  * class SerialExecutor implements Executor {
  84  *   final Queue<Runnable> tasks = new ArrayDeque<Runnable>();
  85  *   final Executor executor;
  86  *   Runnable active;
  87  *
  88  *   SerialExecutor(Executor executor) {
  89  *     this.executor = executor;
  90  *   }
  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();
 104  *     }
 105  *   }
 106  *
 107  *   protected synchronized void scheduleNext() {
 108  *     if ((active = tasks.poll()) != null) {
 109  *       executor.execute(active);
 110  *     }
 111  *   }
 112  * }}</pre>
 113  *
 114  * The <tt>Executor</tt> implementations provided in this package
 115  * implement {@link ExecutorService}, which is a more extensive
 116  * interface.  The {@link ThreadPoolExecutor} class provides an
 117  * extensible thread pool implementation. The {@link Executors} class
 118  * provides convenient factory methods for these Executors.
 119  *
 120  * <p>Memory consistency effects: Actions in a thread prior to
 121  * submitting a {@code Runnable} object to an {@code Executor}
 122  * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
 123  * its execution begins, perhaps in another thread.
 124  *
 125  * @since 1.5
 126  * @author Doug Lea
 127  */
 128 public interface Executor {
 129 
 130     /**
 131      * Executes the given command at some time in the future.  The command
 132      * may execute in a new thread, in a pooled thread, or in the calling