sample/java.util.concurrent.ExecutorCompletionService.txt

   1 *java.util.concurrent.ExecutorCompletionService* *ExecutorCompletionService* ACo
   2
   3 public class ExecutorCompletionService<V>
   4   extends    |java.lang.Object|
   5   implements |java.util.concurrent.CompletionService|
   6
   7 |java.util.concurrent.ExecutorCompletionService_Description|
   8 |java.util.concurrent.ExecutorCompletionService_Fields|
   9 |java.util.concurrent.ExecutorCompletionService_Constructors|
  10 |java.util.concurrent.ExecutorCompletionService_Methods|
  11
  12 ================================================================================
  13
  14 *java.util.concurrent.ExecutorCompletionService_Constructors*
  15 |java.util.concurrent.ExecutorCompletionService(Executor)|Creates an ExecutorCo
  16 |java.util.concurrent.ExecutorCompletionService(Executor,BlockingQueue<Future<V>>)|
  17
  18 *java.util.concurrent.ExecutorCompletionService_Methods*
  19 |java.util.concurrent.ExecutorCompletionService.poll()|
  20 |java.util.concurrent.ExecutorCompletionService.poll(long,TimeUnit)|
  21 |java.util.concurrent.ExecutorCompletionService.submit(Callable<V>)|
  22 |java.util.concurrent.ExecutorCompletionService.submit(Runnable,V)|
  23 |java.util.concurrent.ExecutorCompletionService.take()|
  24
  25 *java.util.concurrent.ExecutorCompletionService_Description*
  26
  27 A (|java.util.concurrent.CompletionService|) that uses a supplied
  28 (|java.util.concurrent.Executor|) to execute tasks. This class arranges that
  29 submitted tasks are, upon completion, placed on a queue accessible using take.
  30 The class is lightweight enough to be suitable for transient use when
  31 processing groups of tasks.
  32
  33
  34
  35 Usage Examples.
  36
  37 Suppose you have a set of solvers for a certain problem, each returning a value
  38 of some type Result, and would like to run them concurrently, processing the
  39 results of each of them that return a non-null value, in some method use(Result
  40 r). You could write this as:
  41
  42
  43
  44 void solve(Executor e, Collection<Callable<Result>> solvers) throws
  45 InterruptedException, ExecutionException { CompletionService<Result> ecs = new
  46 ExecutorCompletionService<Result>(e); for (Callable<Result> s : solvers)
  47 ecs.submit(s); int n = solvers.size(); for (int i = 0; i < n; ++i) { Result r =
  48 ecs.take().get(); if (r != null) use(r); } }
  49
  50 Suppose instead that you would like to use the first non-null result of the set
  51 of tasks, ignoring any that encounter exceptions, and cancelling all other
  52 tasks when the first one is ready:
  53
  54
  55
  56 void solve(Executor e, Collection<Callable<Result>> solvers) throws
  57 InterruptedException { CompletionService<Result> ecs = new
  58 ExecutorCompletionService<Result>(e); int n = solvers.size();
  59 List<Future<Result>> futures = new ArrayList<Future<Result>>(n); Result result
  60 = null; try { for (Callable<Result> s : solvers) futures.add(ecs.submit(s));
  61 for (int i = 0; i < n; ++i) { try { Result r = ecs.take().get(); if (r != null)
  62 { result = r; break; } } catch (ExecutionException ignore) {} } } finally { for
  63 (Future<Result> f : futures) f.cancel(true); }
  64
  65 if (result != null) use(result); }
  66
  67
  68
  69 *java.util.concurrent.ExecutorCompletionService(Executor)*
  70
  71 public ExecutorCompletionService(java.util.concurrent.Executor executor)
  72
  73 Creates an ExecutorCompletionService using the supplied executor for base task
  74 execution and a (|java.util.concurrent.LinkedBlockingQueue|) as a completion
  75 queue.
  76
  77     executor - the executor to use
  78
  79 *java.util.concurrent.ExecutorCompletionService(Executor,BlockingQueue<Future<V>>)*
  80
  81 public ExecutorCompletionService(
  82   java.util.concurrent.Executor executor,
  83   java.util.concurrent.BlockingQueue<java.util.concurrent.Future<V>> completionQueue)
  84
  85 Creates an ExecutorCompletionService using the supplied executor for base task
  86 execution and the supplied queue as its completion queue.
  87
  88     executor - the executor to use
  89     completionQueue - the queue to use as the completion queue normally one dedicated for use by this
  90        service
  91
  92 *java.util.concurrent.ExecutorCompletionService.poll()*
  93
  94 public |java.util.concurrent.Future|<V> poll()
  95
  96
  97
  98
  99
 100 *java.util.concurrent.ExecutorCompletionService.poll(long,TimeUnit)*
 101
 102 public |java.util.concurrent.Future|<V> poll(
 103   long timeout,
 104   java.util.concurrent.TimeUnit unit)
 105   throws |java.lang.InterruptedException|
 106
 107
 108
 109
 110
 111 *java.util.concurrent.ExecutorCompletionService.submit(Callable<V>)*
 112
 113 public |java.util.concurrent.Future|<V> submit(java.util.concurrent.Callable<V> task)
 114
 115
 116
 117
 118
 119 *java.util.concurrent.ExecutorCompletionService.submit(Runnable,V)*
 120
 121 public |java.util.concurrent.Future|<V> submit(
 122   java.lang.Runnable task,
 123   V result)
 124
 125
 126
 127
 128
 129 *java.util.concurrent.ExecutorCompletionService.take()*
 130
 131 public |java.util.concurrent.Future|<V> take()
 132   throws |java.lang.InterruptedException|
 133
 134
 135
 136
 137
 138