线程池相关
源码：
package java.util.concurrent;
public class ExecutorCompletionService<V> implements CompletionService<V> {
private final Executor executor;
private final AbstractExecutorService aes;
private final BlockingQueue<Future<V>> completionQueue;
private class QueueingFuture extends FutureTask<Void> {
QueueingFuture(RunnableFuture<V> task) {
super(task, null);
this.task = task;
}
protected void done() { completionQueue.add(task); }
private final Future<V> task;
}
private RunnableFuture<V> newTaskFor(Callable<V> task) {
if (aes == null)
return new FutureTask<V>(task);
else
return aes.newTaskFor(task);
}
private RunnableFuture<V> newTaskFor(Runnable task, V result) {
if (aes == null)
return new FutureTask<V>(task, result);
else
return aes.newTaskFor(task, result);
}
public ExecutorCompletionService(Executor executor) {
if (executor == null)
throw new NullPointerException();
this.executor = executor;
this.aes = (executor instanceof AbstractExecutorService) ?
(AbstractExecutorService) executor : null;
this.completionQueue = new LinkedBlockingQueue<Future<V>>();
}
public ExecutorCompletionService(Executor executor,
BlockingQueue<Future<V>> completionQueue) {
if (executor == null || completionQueue == null)
throw new NullPointerException();
this.executor = executor;
this.aes = (executor instanceof AbstractExecutorService) ?
(AbstractExecutorService) executor : null;
this.completionQueue = completionQueue;
}
public Future<V> submit(Callable<V> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<V> f = newTaskFor(task);
executor.execute(new QueueingFuture(f));
return f;
}
public Future<V> submit(Runnable task, V result) {
if (task == null) throw new NullPointerException();
RunnableFuture<V> f = newTaskFor(task, result);
executor.execute(new QueueingFuture(f));
return f;
}
public Future<V> take() throws InterruptedException {
return completionQueue.take();
}
public Future<V> poll() {
return completionQueue.poll();
}
public Future<V> poll(long timeout, TimeUnit unit)
throws InterruptedException {
return completionQueue.poll(timeout, unit);
}
}
类 ExecutorCompletionService<V>
所有已实现的接口：
使用提供的 Executor 来执行任务的 CompletionService。
此类将安排那些完成时提交的任务，把它们放置在可使用 take 访问的队列上。
该类非常轻便，适合于在执行几组任务时临时使用。
用法示例。 假定您有针对某个问题的一组求解程序，每个求解程序都能返回某种类型的 Result 值，并且您想同时运行它们，使用方法 use(Result r) 处理返回非 null 值的每个求解程序的返回结果。可以这样编写程序：
void solve(Executor e, Collection<Callable<Result>> solvers)
throws InterruptedException, ExecutionException {
CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
for (Callable<Result> s : solvers)
ecs.submit(s);
int n = solvers.size();
for (int i = 0; i < n; ++i) {
Result r = ecs.take().get();
if (r != null)
use(r);
}
}
假定您想使用任务集中的第一个非 null 结果，而忽略任何遇到异常的任务，并且在第一个任务就绪时取消其他所有任务：
void solve(Executor e, Collection<Callable<Result>> solvers)
throws InterruptedException {
CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
int n = solvers.size();
List<Future<Result>> futures = new ArrayList<Future<Result>>(n);
Result result = null;
try {
for (Callable<Result> s : solvers)
futures.add(ecs.submit(s));
for (int i = 0; i < n; ++i) {
try {
Result r = ecs.take().get();
if (r != null) {
result = r;
break;
}
} catch(ExecutionException ignore) {}
}
}
finally {
for (Future<Result> f : futures)
f.cancel(true);
}
if (result != null)
use(result);
}
构造方法摘要
方法摘要
从类 java.lang.Object 继承的方法
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
ExecutorCompletionService
public ExecutorCompletionService(Executor executor)
使用为执行基本任务而提供的执行程序创建一个 ExecutorCompletionService，并将 LinkedBlockingQueue 作为完成队列。
参数：
executor - 要使用的执行程序
抛出：
NullPointerException - 如果执行程序为 null
ExecutorCompletionService
public ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)
使用为执行基本任务而提供的执行程序创建一个 ExecutorCompletionService，并将所提供的队列作为其完成队列。
参数：
executor - 要使用的执行程序
completionQueue - 用作完成队列的队列，通常是专供此服务使用的队列
抛出：
NullPointerException - 如果执行程序或 completionQueue 为 null
submit
public Future<V> submit(Callable<V> task)
从接口 CompletionService 复制的描述
提交要执行的值返回任务，并返回表示挂起的任务结果的 Future。在完成时，可能会提取或轮询此任务。
指定者：
接口 CompletionService<V> 中的 submit
参数：
task - 要提交的任务
返回：
一个表示挂起的任务完成的 Future
submit
public Future<V> submit(Runnable task, V result)
从接口 CompletionService 复制的描述
提交要执行的 Runnable 任务，并返回一个表示任务完成的 Future，可以提取或轮询此任务。
指定者：
接口 CompletionService<V> 中的 submit
参数：
task - 要提交的任务
result - 要返回的已成功完成任务的结果
返回：
一个表示挂起的任务完成的 Future，其 get() 方法将返回完成时给出的结果值
take
public Future<V> take() throws InterruptedException
从接口 CompletionService 复制的描述
获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。
指定者：
接口 CompletionService<V> 中的 take
返回：
表示下一个已完成任务的 Future
抛出：
InterruptedException - 如果在等待时被中断
poll
public Future<V> poll()
从接口 CompletionService 复制的描述
获取并移除表示下一个已完成任务的 Future，如果不存在这样的任务，则返回 null。
指定者：
接口 CompletionService<V> 中的 poll
返回：
表示下一个已完成任务的 Future；如果不存在这样的任务，则返回 null
poll
public Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException
从接口 CompletionService 复制的描述
获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则将等待指定的时间（如果有必要）。
指定者：
接口 CompletionService<V> 中的 poll
参数：
timeout - 放弃之前需要等待的时间长度，以 unit 为时间单位
unit - 确定如何解释 timeout 参数的 TimeUnit
返回：
表示下一个已完成任务的 Future；如果等待了指定时间仍然不存在这样的任务，则返回 null
抛出：
InterruptedException - 如果在等待时被中断