sample/java.util.concurrent.ExecutorCompletionService.txt

   1 *java.util.concurrent.ExecutorCompletionService* *ExecutorCompletionService* ACo
   2
   3 public class ExecutorCompletionService
   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)|Creates
  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)|
  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 *java.util.concurrent.ExecutorCompletionService(Executor)*
  69
  70 public ExecutorCompletionService(java.util.concurrent.Executor executor)
  71
  72 Creates an ExecutorCompletionService using the supplied executor for base task
  73 execution and a (|java.util.concurrent.LinkedBlockingQueue|) as a completion
  74 queue.
  75
  76     executor - the executor to use
  77
  78 *java.util.concurrent.ExecutorCompletionService(Executor,BlockingQueue)*
  79
  80 public ExecutorCompletionService(
  81   java.util.concurrent.Executor executor,
  82   java.util.concurrent.BlockingQueue completionQueue)
  83
  84 Creates an ExecutorCompletionService using the supplied executor for base task
  85 execution and the supplied queue as its completion queue.
  86
  87     executor - the executor to use
  88     completionQueue - the queue to use as the completion queue normally one dedicated for use by this
  89        service
  90
  91 *java.util.concurrent.ExecutorCompletionService.poll()*
  92
  93 public |java.util.concurrent.Future| poll()
  94
  95
  96
  97
  98 *java.util.concurrent.ExecutorCompletionService.poll(long,TimeUnit)*
  99
 100 public |java.util.concurrent.Future| poll(
 101   long timeout,
 102   java.util.concurrent.TimeUnit unit)
 103   throws |java.lang.InterruptedException|
 104
 105
 106
 107
 108 *java.util.concurrent.ExecutorCompletionService.submit(Callable)*
 109
 110 public |java.util.concurrent.Future| submit(java.util.concurrent.Callable task)
 111
 112
 113
 114
 115 *java.util.concurrent.ExecutorCompletionService.submit(Runnable,V)*
 116
 117 public |java.util.concurrent.Future| submit(
 118   java.lang.Runnable task,
 119   java.lang.Object result)
 120
 121
 122
 123
 124 *java.util.concurrent.ExecutorCompletionService.take()*
 125
 126 public |java.util.concurrent.Future| take()
 127   throws |java.lang.InterruptedException|
 128
 129
 130
 131
 132