多线程异步非阻塞之CompletionService
引自:https://www.cnblogs.com/swiftma/p/6691235.html
上节,我们提到,在异步任务程序中,一种常见的场景是,主线程提交多个异步任务,然后希望有任务完成就处理结果,并且按任务完成顺序逐个处理,对于这种场景,Java并发包提供了一个方便的方法,使用CompletionService,这是一个接口,它的实现类是ExecutorCompletionService,本节我们就来探讨它们。
基本用法
接口和类定义
与77节介绍的ExecutorService一样,CompletionService也可以提交异步任务,它的不同是,它可以按任务完成顺序获取结果,其具体定义为:
public interface CompletionService<V> { Future<V> submit(Callable<V> task); Future<V> submit(Runnable task, V result); Future<V> take() throws InterruptedException; Future<V> poll(); Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException; }
其submit方法与ExecutorService是一样的,多了take和poll方法,它们都是获取下一个完成任务的结果,take()会阻塞等待,poll()会立即返回,如果没有已完成的任务,返回null,带时间参数的poll方法会最多等待限定的时间。
CompletionService的主要实现类是ExecutorCompletionService,它依赖于一个Executor完成实际的任务提交,而自己主要负责结果的排队和处理,它的构造方法有两个:
public ExecutorCompletionService(Executor executor) public ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)
至少需要一个Executor参数,可以提供一个BlockingQueue参数,用作完成任务的队列,没有提供的话,ExecutorCompletionService内部会创建一个LinkedBlockingQueue。
基本示例
我们在77节的invokeAll的示例中,演示了并发下载并分析URL的标题,那个例子中,是要等到所有任务都完成才处理结果的,这里,我们修改一下,一有任务完成就输出其结果,代码如下:
public class CompletionServiceDemo { static class UrlTitleParser implements Callable<String> { private String url; public UrlTitleParser(String url) { this.url = url; } @Override public String call() throws Exception { Document doc = Jsoup.connect(url).get(); Elements elements = doc.select("head title"); if (elements.size() > 0) { return url + ": " + elements.get(0).text(); } return null; } } public static void parse(List<String> urls) throws InterruptedException { ExecutorService executor = Executors.newFixedThreadPool(10); try { CompletionService<String> completionService = new ExecutorCompletionService<>( executor); for (String url : urls) { completionService.submit(new UrlTitleParser(url)); } for (int i = 0; i < urls.size(); i++) { Future<String> result = completionService.take(); try { System.out.println(result.get()); } catch (ExecutionException e) { e.printStackTrace(); } } } finally { executor.shutdown(); } } public static void main(String[] args) throws InterruptedException { List<String> urls = Arrays.asList(new String[] { "http://www.cnblogs.com/swiftma/p/5396551.html", "http://www.cnblogs.com/swiftma/p/5399315.html", "http://www.cnblogs.com/swiftma/p/5405417.html", "http://www.cnblogs.com/swiftma/p/5409424.html" }); parse(urls); } }
在parse方法中,首先创建了一个ExecutorService,然后才是CompletionService,通过后者提交任务、按完成顺序逐个处理结果,这样,是不是很方便?
基本原理
ExecutorCompletionService是怎么让结果有序处理的呢?其实,也很简单,如前所述,它有一个额外的队列,每个任务完成之后,都会将代表结果的Future入队。
那问题是,任务完成后,怎么知道入队呢?我们具体来看下。
在77节我们介绍过FutureTask,任务完成后,不管是正常完成、异常结束、还是被取消,都会调用finishCompletion方法,而该方法会调用一个done方法,该方法代码为:
protected void done() { }
它的实现为空,但它是一个protected方法,子类可以重写该方法。
在ExecutorCompletionService中,提交的任务类型不是一般的FutureTask,而是一个子类QueueingFuture,如下所示:
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; }
该子类重写了done方法,在任务完成时将结果加入到完成队列中,其代码为:
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; }
ExecutorCompletionService的take/poll方法就是从该队列获取结果,如下所示:
public Future<V> take() throws InterruptedException { return completionQueue.take(); }
实现invokeAny
我们在77节提到,AbstractExecutorService的invokeAny的实现,就利用了ExecutorCompletionService,它的基本思路是,提交任务后,通过take方法获取结果,获取到第一个有效结果后,取消所有其他任务,不过,它的具体实现有一些优化,比较复杂。我们看一个模拟的示例,从多个搜索引擎查询一个关键词,但只要任意一个的结果就可以,模拟代码如下:
public class InvokeAnyDemo { static class SearchTask implements Callable<String> { private String engine; private String keyword; public SearchTask(String engine, String keyword) { this.engine = engine; this.keyword = keyword; } @Override public String call() throws Exception { // 模拟从给定引擎搜索结果 Thread.sleep(engine.hashCode() % 1000); return "<result for> " + keyword; } } public static String search(List<String> engines, String keyword) throws InterruptedException { ExecutorService executor = Executors.newFixedThreadPool(10); CompletionService<String> cs = new ExecutorCompletionService<>(executor); List<Future<String>> futures = new ArrayList<Future<String>>( engines.size()); String result = null; try { for (String engine : engines) { futures.add(cs.submit(new SearchTask(engine, keyword))); } for (int i = 0; i < engines.size(); i++) { try { result = cs.take().get(); if (result != null) { break; } } catch (ExecutionException ignore) { // 出现异常,结果无效,继续 } } } finally { // 取消所有任务,对于已完成的任务,取消没有什么效果 for (Future<String> f : futures) f.cancel(true); executor.shutdown(); } return result; } public static void main(String[] args) throws InterruptedException { List<String> engines = Arrays.asList(new String[] { "www.baidu.com", "www.sogou.com", "www.so.com", "www.google.com" }); System.out.println(search(engines, "老马说编程")); } }
SearchTask模拟从指定搜索引擎查询结果,search利用CompletionService/ExecutorService执行并发查询,在得到第一个有效结果后,取消其他任务。
以下示例引自:https://blog.csdn.net/woshilijiuyi/article/details/78970497
package test; import java.util.concurrent.BlockingQueue; 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; import java.util.concurrent.Future; import java.util.concurrent.LinkedBlockingQueue; /** * CompletionService多线程批处理任务 * * @author Administrator * */ public class CompletionServiceTest { public static void main(String[] args) throws Exception { CompletionServiceTest cst = new CompletionServiceTest(); cst.count1(); System.out.println("-------------------------"); cst.count2(); } /** * Executors结合BlockingQueue保存每个Future,按先进先出的顺序得到线程的结果 * BlockingQueue是先进先出的列队。为什么说是阻塞(Blocking)的呢?是因为 BlockingQueue 支持当获取队列元素但是队列为空时,会阻塞等待队列中有元素再返回; * 也支持添加元素时,如果队列已满,那么等到队列可以放入新元素时再放入。 * 存在的问题:对于本例中的线程3,由于比较耗时,将导致获取结果被阻塞,等待线程进入队列才可以取出。 * * @throws Exception */ public void count1() throws Exception { ExecutorService exec = Executors.newCachedThreadPool(); //线程池 BlockingQueue<Future<Integer>> queue = new LinkedBlockingQueue<Future<Integer>>(); //阻塞列队 System.out.println("阻塞列队获取结果......"); for (int i = 0; i < 10; i++) { Future<Integer> future = exec.submit(getTask(i)); queue.add(future); //先进先出排序 } Thread.sleep(5000); //确保全部Future进入队列,没有这个睡眠队列中有值就会被获取 System.out.println(); int queueSize = queue.size(); for (int i = 0; i < queueSize; i++) { System.out.print("取出:"+queue.take().get()+" "); //按进去的顺序取出 } exec.shutdown(); } /** * 使用CompletionService(完成服务)异步非阻塞获取线程执行的结果,结果按照完成先后顺序排序 * CompletionService整合了Executor和BlockingQueue的功能,不同之处是executor.execute(new QueueingFuture(f)); * 而QueueingFuture实现了FutureTask,并且重写了done()方法。该方法是异步计算完成后调用的回调函数,在该方法里将完成的task放入BlockingQueue队列。 * 不需要等待线程中某个耗时操作,会按照线程完成时间返回结果。 * * @throws InterruptedException * @throws ExecutionException */ public void count2() throws InterruptedException, ExecutionException { ExecutorService exec = Executors.newCachedThreadPool(); CompletionService<Integer> execcomp = new ExecutorCompletionService<Integer>(exec); System.out.println("CompletionService获取结果......"); for (int i = 0; i < 10; i++) { execcomp.submit(getTask(i)); //已经按线程完成顺序排序进入队列 } System.out.println(); for (int i = 0; i < 10; i++) { // take()阻塞等待获取队列中的结果 Future<Integer> future = execcomp.take(); System.out.print("取出:"+future.get()+" "); } exec.shutdown(); } /** * 得到一个任务 * * @return */ public Callable<Integer> getTask(int i) { Callable<Integer> task = new Callable<Integer>() { @Override public Integer call() throws Exception { if(i==3){ Thread.sleep(i*1000); //让第三个线程睡眠3秒 } System.out.print(i + "\t"); return i; } }; return task; } }