Java并发之CompletionService详解

CompletionService是什么?

它是JUC包中的一个接口类,默认实现类只有一个ExecutorCompletionService。

 

CompletionService干什么的?

它将异步任务的生成和执行结果的处理进行了解耦,用来执行Callable的任务(实际也是通过Executor线程池执行的,只是它又加了一层封装),我们只需要调用它的take(阻塞)/poll(非阻塞)方法便可以获取到执行完的任务结果,最先获取到的必定是先执行完的异步任务结果。

主要应用场景:同时执行多个Callable任务,并且需对任务的返回结果进行处理。若想优先处理先执行完的任务结果,使用它尤其方便

 

ExecutorCompletionService 源码解析

有三个成员变量,关键的是下面标注的变量1、变量2:

1 public class ExecutorCompletionService<V> implements CompletionService<V> {
2     private final Executor executor; // 变量1: 线程池
3     private final AbstractExecutorService aes;
4     private final BlockingQueue<Future<V>> completionQueue; // 变量2: 阻塞队列

两个构造器,如下,用于初始化上面的三个成员变量,可以看到Executor线程池是必传的:

1     public ExecutorCompletionService(Executor executor) {
2         if (executor == null)
3             throw new NullPointerException();
4         this.executor = executor;
5         this.aes = (executor instanceof AbstractExecutorService) ?
6             (AbstractExecutorService) executor : null;
7         this.completionQueue = new LinkedBlockingQueue<Future<V>>();
8     }
1     public ExecutorCompletionService(Executor executor,
2                                      BlockingQueue<Future<V>> completionQueue) {
3         if (executor == null || completionQueue == null)
4             throw new NullPointerException();
5         this.executor = executor;
6         this.aes = (executor instanceof AbstractExecutorService) ?
7             (AbstractExecutorService) executor : null;
8         this.completionQueue = completionQueue;
9     }

核心方法submit,把task封装成一个QueueingFuture,作为执行任务交给线程池执行:

1     public Future<V> submit(Callable<V> task) {
2         if (task == null) throw new NullPointerException();
3         RunnableFuture<V> f = newTaskFor(task);
4         executor.execute(new QueueingFuture(f));
5         return f;
6     }

下面再来看一下QueueingFuture对象,也是一个核心对象,如下所示。QueueingFuture是ExecutorCompletionService的私有内部类,它重写了FutureTask的done()方法。当任务执行完成set值的时候,会调用done方法,在done方法中将task存入阻塞队列。先执行完的任务就会先放入阻塞队列,所以我们从队列中取结果的时候,必定是先取到先执行完的任务。

1     private class QueueingFuture extends FutureTask<Void> {
2         QueueingFuture(RunnableFuture<V> task) {
3             super(task, null);
4             this.task = task;
5         }
6         protected void done() { completionQueue.add(task); }
7         private final Future<V> task;
8     }

总结一下,ExecutorCompletionService是通过QueueingFuture的done方法和阻塞队列实现的按照异步任务返回顺序来返回结果

 

ExecutorCompletionService和ExecutorService的使用demo示例

Callable类:

 1 class CsCallable implements Callable<String> {
 2     private String name;
 3     private long milli;
 4 
 5     public CsCallable(String name, long milli) {
 6         this.name = name;
 7         this.milli = milli;
 8     }
 9 
10     @Override
11     public String call() throws Exception {
12         System.out.println("name:" + name);
13         Thread.sleep(milli);
14         return name + " after " + milli + "ms call back.";
15     }
16 }

ExecutorCompletionService的demo:

 1 public class CompletionServiceDemo {
 2     public static void main(String[] args) throws Exception {
 3         CompletionService completionService = new ExecutorCompletionService(Executors.newFixedThreadPool(4));
 4         completionService.submit(new CsCallable("xxx", 5000));
 5         completionService.submit(new CsCallable("www", 2000));
 6         completionService.submit(new CsCallable("zzz", 14000));
 7         completionService.submit(new CsCallable("yyy", 9000));
 8         for (int i = 0; i < 4; i++) {
 9             System.out.println(completionService.take().get());
10         }
11         System.out.println("----- main over -----");
12     }
13 }

执行结果如下,可以看到早完成的任务结果能先获取到

 

 

ExecutorService的demo:

 1 public class ExecutorServiceDemo {
 2     public static void main(String[] args) throws Exception {
 3         ExecutorService executorService = Executors.newFixedThreadPool(4);
 4         List<Future<String>> list = new ArrayList<>();
 5         list.add(executorService.submit(new CsCallable("xxx", 5000)));
 6         list.add(executorService.submit(new CsCallable("www", 2000)));
 7         list.add(executorService.submit(new CsCallable("zzz", 14000)));
 8         list.add(executorService.submit(new CsCallable("yyy", 9000)));
 9         for (Future<String> future : list) {
10             System.out.println(future.get());
11         }
12         System.out.println("----- main over -----");
13     }
14 }

执行结果如下,只能按照指定的顺序处理返回结果,无法先处理早完成的任务

 

posted on 2021-02-24 22:41  淡墨痕  阅读(923)  评论(0编辑  收藏  举报