CompletionService 是 Java 中 java.util.concurrent 包的一部分，用于管理并发任务的执行，并以完成的顺序提供结果。它结合了线程池和阻塞队列的功能，用于提交任务并按照任务完成的顺序来检索结果，而不是按照任务提交的顺序。
接口CompletionService的功能是以异步的方式一边生产新的任务，一边处理已完成任务的结果，这样可以将执行任务与处理任务分离开来进行处理。使用submit执行任务，使用take取得已完成的任务，并按照完成这些任务的时间顺序处理它们的结果。
1.主要功能：
1. 任务提交： CompletionService 允许你提交 Callable 或 Runnable 任务，这些任务会被执行器（通常是线程池）执行。
2. 结果按完成顺序检索： CompletionService 提供了一种机制，可以在任务完成后立即获取其结果，而不必等待其他尚未完成的任务。这与传统的线程池相比是一大优势，因为在传统的线程池中，你可能需要按照任务提交的顺序来等待结果。
3. 减少轮询等待时间： 使用 CompletionService 可以有效减少等待时间，因为你可以立即处理已完成的任务，而不是被迫等待所有任务都完成。
2.关键方法：
CompletionService 是一个接口，通常通过其实现类 ExecutorCompletionService 来使用。它主要有以下几个重要的方法：
• submit(Callable<V> task) 和 submit(Runnable task, V result)： 提交一个任务给执行器执行。Callable 返回一个结果，而 Runnable 通常不会返回结果，除非你指定一个结果。
• Future<V> take()： 检索并移除下一个已完成的任务，如果没有任务完成，则会阻塞直到一个任务完成。
• Future<V> poll()： 检索并移除下一个已完成的任务，如果没有任务完成，则返回 null。
• Future<V> poll(long timeout, TimeUnit unit)： 在指定的时间内检索并移除下一个已完成的任务，如果在指定时间内没有任务完成，则返回 null。
接口CompletionService的结构比较简洁，仅有一个实现类ExecutorCompletionService，该类的构造方法如图：
从构造方法的声明中可以发现，类ExecutorCompletionService需要依赖于Executor对象，大部分的实现也就是使用线程池ThreadPoolExecutor对象。
3. 使用CompletionService解决Future的缺点：
Future具有阻塞同步性，这样的代码运行效率会大打折扣，接口CompletionService可以解决这样的问题。
在本示例中使用CompletionService接口中的take（）方法，它的主要作用就是取得Future对象，方法声明结构如下：
public Future<V>take（）throws InterruptedException
创建类MyCallable.java代码如下：
package mycallable;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
private String username;
private long sleepValue;
public MyCallable(String username, long sleepValue) {
super();
this.username = username;
this.sleepValue = sleepValue;
}
@Override
public String call() throws Exception {
System.out.println(username);
Thread.sleep(sleepValue);
return "return " + username;
}
}类Test1.java代码如下：
package test;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import mycallable.MyCallable;
public class Test1 {
public static void main(String[] args) {
try {
MyCallable callable1 = new MyCallable("username1", 5000);
MyCallable callable2 = new MyCallable("username2", 4000);
MyCallable callable3 = new MyCallable("username3", 3000);
MyCallable callable4 = new MyCallable("username4", 2000);
MyCallable callable5 = new MyCallable("username5", 1000);
List<Callable> callableList = new ArrayList<Callable>();
callableList.add(callable1);
callableList.add(callable2);
callableList.add(callable3);
callableList.add(callable4);
callableList.add(callable5);
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 5,
TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
CompletionService csRef = new ExecutorCompletionService(executor);
for (int i = 0; i < 5; i++) {
csRef.submit(callableList.get(i));
}
for (int i = 0; i < 5; i++) {
System.out.println("等待打印第" + (i + 1) + "个返回值");
System.out.println(csRef.take().get());
}
// 按乱序打印的效果
// 说明一个Future对应当前先执行完的Callable任务
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}代码解释
1. 创建 MyCallable 实例：
• 代码首先创建了 5 个 MyCallable 实例，每个实例都模拟不同的任务，任务的 sleepValue 从 5000 毫秒（5 秒）到 1000 毫秒（1 秒）不等。
• MyCallable 是你之前定义的类，实现了 Callable<String> 接口，并在 call() 方法中执行睡眠操作后返回一个字符串结果。
2. 将 MyCallable 对象添加到列表：
• 创建了一个 List<Callable> 来存储这些 MyCallable 实例，稍后将用这些实例来提交任务。
3. 创建线程池：
• 使用 ThreadPoolExecutor 创建了一个线程池，核心线程数为 5，最大线程数为 10，线程空闲时间为 5 秒，任务队列是一个 LinkedBlockingDeque。
4. 创建 CompletionService：
• 使用 ExecutorCompletionService 包装线程池，CompletionService 是一个用于管理任务提交和结果获取的服务，它可以让你按任务完成的顺序获取结果。
5. 提交任务：
• 通过 CompletionService 的 submit() 方法，将 5 个 MyCallable 任务提交到线程池中执行。
6. 获取任务结果：
• 通过 CompletionService 的 take() 方法获取任务的完成结果。take() 方法会阻塞直到有任务完成，随后通过 Future.get() 获取该任务的执行结果。
• 由于任务按执行完成的顺序返回结果，所以打印的顺序可能与任务提交的顺序不同。
程序运行结果如图:
从打印的结果来看，CompletionService完全解决了Future阻塞的特性，也就是使用CompletionService接口后，哪个任务先执行完，哪个任务的返回值就先打印。
在CompletionService接口中如果当前没有任务被执行完，则csRef.take（）.get（）方法还是呈阻塞特性。
4. 使用take（）方法
方法take（）取得最先完成任务的Future对象，谁执行时间最短谁最先返回。
package test.run;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Run {
public static void main(String[] args) {
try {
// take方法：获取并移除表示下一个已完成任务的 Future，如果目前不存在这样的任务，则等待。
ExecutorService executorService = Executors.newCachedThreadPool();
CompletionService csRef = new ExecutorCompletionService(
executorService);
for (int i = 0; i < 10; i++) {
csRef.submit(new Callable<String>() {
public String call() throws Exception {
long sleepValue = (int) (Math.random() * 1000);
System.out.println("sleep=" + sleepValue + " "
+ Thread.currentThread().getName());
Thread.sleep(sleepValue);
return "高洪岩：" + sleepValue + " "
+ Thread.currentThread().getName();
}
});
}
for (int i = 0; i < 10; i++) {
System.out.println(csRef.take().get());
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}程序运行结果如图:
从运行结果来看，方法take（）是按任务执行的速度，从快到慢的顺序获得Future对象，因为打印的时间是从小到大。
5. 使用poll（）方法
方法poll（）的作用是获取并移除表示下一个已完成任务的Future，如果不存在这样的任务，则返回null，方法poll（）无阻塞的效果.
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Run {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
CompletionService csRef = new ExecutorCompletionService(executorService);
for (int i = 0; i < 1; i++) {
csRef.submit(new Callable<String>() {
public String call() throws Exception {
Thread.sleep(3000);
System.out.println("3秒过后了");
return "高洪岩3s";
}
});
}
for (int i = 0; i < 1; i++) {
System.out.println(csRef.poll());
}
}
}程序运行结果如图:
从运行结果来看，方法poll（）返回的Future为null，因为当前没有任何已完成任务的Future对象，所以返回为null，通过此实验证明poll（）方法不像take（）方法具有阻塞的效果。
5.类CompletionService与异常
6.6 类CompletionService与异常
使用CompletionService执行任务的过程中不可避免会出现各种情况的异常，下面来实验一下CompletionService对异常处理的流程。
类MyCallableA.java代码如下：
package mycallable;
import java.util.concurrent.Callable;
public class MyCallableA implements Callable<String> {
public String call() throws Exception {
System.out.println("MyCallableA begin " + System.currentTimeMillis());
Thread.sleep(1000);
System.out.println("MyCallableA end " + System.currentTimeMillis());
return "returnA";
}
}类MyCallableB.java代码如下：
package mycallable;
import java.util.concurrent.Callable;
public class MyCallableB implements Callable<String> {
public String call() throws Exception {
System.out.println("MyCallableB begin " + System.currentTimeMillis());
Thread.sleep(5000);
int i = 0;
if (i == 0) {
throw new Exception("抛出异常！");
}
System.out.println("MyCallableB end " + System.currentTimeMillis());
return "returnB";
}
}运行类Run1.java代码如下：
package test.run;
import java.util.concurrent.CompletionService;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import mycallable.MyCallableA;
import mycallable.MyCallableB;
public class Run1 {
public static void main(String[] args) {
try {
MyCallableA callableA = new MyCallableA();
MyCallableB callableB = new MyCallableB();
Executor executor = Executors.newSingleThreadExecutor();
CompletionService csRef = new ExecutorCompletionService(executor);
csRef.submit(callableA);
csRef.submit(callableB);
for (int i = 0; i < 2; i++) {
System.out.println("zzzzzzzzzzzz" + " " + csRef.take());
}
System.out.println("main end!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}程序运行结果如图6-12所示。
图6-12 打印FutureTask对象
上面的示例虽然MyCallableB.java出现异常，但并没有调用FutureTask类的get（）方法，所以不出现异常。
类Run2.java代码如下：
package test.run;
s
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import mycallable.MyCallableA;
import mycallable.MyCallableB;
public class Run2 {
public static void main(String[] args) {
try {
MyCallableA callableA = new MyCallableA();
MyCallableB callableB = new MyCallableB();
Executor executor = Executors.newSingleThreadExecutor();
CompletionService csRef = new ExecutorCompletionService(executor);
csRef.submit(callableA);//先执行的A
csRef.submit(callableB);//后执行的B
for (int i = 0; i < 2; i++) {
System.out.println("zzzzzzzzzzzz" + " " + csRef.take().get());
}
System.out.println("main end!");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}程序运行结果如图6-13所示。
图6-13 任务A正常任务B出现异常
任务A执行时间较少，也并未出现异常，正确打印任务A的返回值，任务B出现异常。
类Run3.java代码如下：
package test.run;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import mycallable.MyCallableA;
import mycallable.MyCallableB;
public class Run3 {
public static void main(String[] args) {
try {
MyCallableA callableA = new MyCallableA();
MyCallableB callableB = new MyCallableB();
Executor executor = Executors.newSingleThreadExecutor();
CompletionService csRef = new ExecutorCompletionService(executor);
csRef.submit(callableB);// 先执行B
csRef.submit(callableA);// 后执行A
for (int i = 0; i < 2; i++) {
System.out.println("zzzzzzzzzzzz" + " " + csRef.take().get());
}
System.out.println("main end!");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}程序运行结果如图6-14所示。
图6-14 任务B出现异常任务A并未输出
类Run4.java代码如下：
package test.run;
import java.util.concurrent.CompletionService;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import mycallable.MyCallableA;
import mycallable.MyCallableB;
public class Run4 {
public static void main(String[] args) {
try {
MyCallableA callableA = new MyCallableA();
MyCallableB callableB = new MyCallableB();
Executor executor = Executors.newSingleThreadExecutor();
CompletionService csRef = new ExecutorCompletionService(executor);
csRef.submit(callableA);
csRef.submit(callableB);
for (int i = 0; i < 2; i++) {
System.out.println("zzzzzzzzzzzz" + " " + csRef.poll());
}
Thread.sleep(6000);
System.out.println("A处" + " " + csRef.poll());
System.out.println("B处" + " " + csRef.poll());
System.out.println("main end!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}程序运行结果如图6-15所示。
图6-15 直接输出FutureTask对象
类Run5.java代码如下：
package test.run;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import mycallable.MyCallableA;
import mycallable.MyCallableB;
public class Run5 {
public static void main(String[] args) {
try {
MyCallableA callableA = new MyCallableA();
MyCallableB callableB = new MyCallableB();
Executor executor = Executors.newSingleThreadExecutor();
CompletionService csRef = new ExecutorCompletionService(executor);
csRef.submit(callableA);// 先执行A
csRef.submit(callableB);// 后执行B
for (int i = 0; i < 2; i++) {
System.out.println("zzzzzzzzzzzz" + " " + csRef.poll());
}
Thread.sleep(6000);
System.out.println("A处" + " " + csRef.poll().get());
System.out.println("B处" + " " + csRef.poll().get());
System.out.println("main end!");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}程序运行结果如图6-16所示。
图6-16 打印任务A返回值任务B出现异常
类Run6.java代码如下：
package test.run;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.Executors;
import mycallable.MyCallableA;
import mycallable.MyCallableB;
public class Run6 {
public static void main(String[] args) {
try {
MyCallableA callableA = new MyCallableA();
MyCallableB callableB = new MyCallableB();
Executor executor = Executors.newSingleThreadExecutor();
CompletionService csRef = new ExecutorCompletionService(executor);
csRef.submit(callableB);// 先执行B
csRef.submit(callableA);// 后执行A
for (int i = 0; i < 2; i++) {
System.out.println("zzzzzzzzzzzz" + " " + csRef.poll());
}
Thread.sleep(6000);
System.out.println("A处" + " " + csRef.poll().get());
System.out.println("B处" + " " + csRef.poll().get());
System.out.println("main end!");
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}程序运行结果如图6-17所示。
图6-17 任务A并未打印任务B抛出异常
