java多線程異步獲取結果CompletionService
一、前言：
在異步任務程序中，一種常見的場景是，主線程提交多個異步任務，然後希望有任務完成就處理結果，並且按任務完成順序逐個處理，對於這種場景，Java併發包提供的CompletionService 方法可以幫我們解決。
二、定義：
下面我們來看一下這個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(): 用於提交一個需要返回果的任務。該方法返回一個Future對象，通過調用這個對象的get()方法，我們就能獲得返回結 果。get()方法會一直阻塞，直到返回結果返回 (與ExecutorService 方法一樣)
take(): 獲取下一個完成任務的結果，take()會阻塞等待，直到結果返回
poll(): 獲取下一個結果，是立刻返回結果，不論是否任務已經完成，如果沒有已完成的任務，返回null，帶時間參數的poll方法會最多等待限定的時間
三、實現原理：
CompletionService的主要實現類是ExecutorCompletionService，它依賴於一個Executor完成實際的任務提交，而自己主要負責結果的排隊和處理，它的構造方法有兩個：
public ExecutorCompletionService(Executor executor)
public ExecutorCompletionService(Executor executor, BlockingQueue<Future<V>> completionQueue)
至少需要一個Executor參數，可以提供一個BlockingQueue參數，用作完成任務的隊列，沒有提供的話，ExecutorCompletionService內部會創建一個LinkedBlockingQueue
這個BlockingQueue或者LinkedBlockingQueue 就是用來對結果進行排隊和排序的
舉一個簡單的例子
演示了併發下載並分析URL的標題，一有任務完成就輸出其結果，如果沒有完成的就阻塞等待
package com.test;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.*;
/**
* 異步獲取批量結果
*/
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 {
//使用jsoup第三方解析網頁
//獲取網頁的dom結構數據
Document doc = Jsoup.connect(url)
.header("accept-charset","utf-8")
.get();
//獲取title的元素
Elements elements = doc.select("title");
if (elements.size() > 0) {
return url + ": " + elements.get(0).text();
}
return null;
}
}
public static void parse(List<String> urls) throws InterruptedException {
//創建線程池 最大10個線程
ExecutorService executor = Executors.newFixedThreadPool(10);
try {
//創建接受任務的Completion
CompletionService<String> completionService = new ExecutorCompletionService<>(
executor);
//依次提交任務
for (String url : urls) {
completionService.submit(new UrlTitleParser(url));
}
//依次獲取任務結果 注意take函數是阻塞函數 是按完成任務先後排序的 並不是按提交任務先後
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[] {
"https://blog.csdn.net/FireAny2010/article/details/102837272",
"https://blog.csdn.net/FireAny2010/article/details/102798925",
"https://blog.csdn.net/FireAny2010/article/details/102605309",
"https://blog.csdn.net/FireAny2010/article/details/102718862" });
parse(urls);
}
}
四、具體分析
1、ExecutorCompletionService是怎麼讓結果有序處理的呢？
答：如前所述，它有一個額外的隊列，每個任務完成之後，都會將代表結果的Future入隊。
2、任務完成後，怎麼知道入隊呢？
答：我們要知道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
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執行併發查詢，在得到第一個有效結果後，取消其他任務