多線程搜索操作

Question

我有一個接受一系列查詢的方法，我需要針對不同的搜索引擎Web API（如Google或Yahoo）運行它們。爲了並行化進程，爲每個查詢生成一個線程，最後在join ed之後​​，因爲我的應用程序只能繼續之後我的結果爲每查詢。目前，我有東西沿着這些路線：

public abstract class class Query extends Thread { 
    private String query; 

    public abstract Result[] querySearchEngine(); 
    @Override 
    public void run() { 
     Result[] results = querySearchEngine(query); 
     Querier.addResults(results); 
    } 

} 

public class GoogleQuery extends Query { 
    public Result querySearchEngine(String query) { 
     // access google rest API 
    } 
} 

public class Querier { 
    /* Every class that implements Query fills this array */ 
    private static ArrayList<Result> aggregatedResults; 

    public static void addResults(Result[]) { // add to aggregatedResults } 

    public static Result[] queryAll(Query[] queries) { 
     /* for each thread, start it, to aggregate results */ 
     for (Query query : queries) { 
      query.start(); 
     } 
     for (Query query : queries) { 
      query.join(); 
     } 
     return aggregatedResults; 
    } 
} 

最近，我發現有一個新 API在Java中做兼職。即，Callable接口，FutureTask和ExecutorService。我想知道這個新API是否應該被使用，如果它們比傳統API更有效，Runnable和Thread。

研究這個新的API後，我想出了下面的代碼（簡體版）：

public abstract class Query implements Callable<Result[]> { 
     private final String query; // gets set in the constructor 

     public abstract Result[] querySearchEngine(); 
     @Override 
     public Result[] call() { 
      return querySearchEngine(query); 
     } 
    } 

public class Querier { 
     private ArrayList<Result> aggregatedResults; 

     public Result[] queryAll(Query[] queries) { 
      List<Future<Result[]>> futures = new ArrayList<Future<Result[]>>(queries.length); 
      final ExecutorService service = Executors.newFixedThreadPool(queries.length); 
      for (Query query : queries) { 
       futures.add(service.submit(query)); 
      } 
      for (Future<Result[]> future : futures) { 
       aggregatedResults.add(future.get()); // get() is somewhat similar to join? 
      } 
      return aggregatedResults; 
     } 
    } 

我是新來的這個併發API，我想知道是否有東西，可以在上面的代碼中是改進了，並且如果它比第一個選項更好（使用Thread）。有一些我沒有探索的類，例如FutureTask等等。我很樂意聽到關於此的任何建議。

Answer 1

您的代碼有幾個問題。

1. 您應該使用ExecutorService.invokeAll（）方法。 創建新線程和新線程池的成本可能很高（儘管可能與調用外部搜索引擎相比）。 invokeAll（）可以爲你管理線程。
2. 你可能不想混合使用數組和泛型。
3. 您正在調用aggregatedResults.add（）而不是addAll（）。
4. 當它們可能是queryAll（）函數調用的本地對象時，不需要使用成員變量。

所以，像下面應該工作：

public abstract class Query implements Callable<List<Result>> { 
    private final String query; // gets set in the constructor 

    public abstract List<Result> querySearchEngine(); 
    @Override 
    public List<Result> call() { 
     return querySearchEngine(query); 
    } 
} 

public class Querier { 
    private static final ExecutorService executor = Executors.newCachedThreadPool(); 

    public List<Result> queryAll(List<Query> queries) { 
     List<Future<List<Result>>> futures = executor.submitAll(queries); 
     List<Result> aggregatedResults = new ArrayList<Result>(); 
     for (Future<List<Result>> future : futures) { 
      aggregatedResults.addAll(future.get()); // get() is somewhat similar to join? 
     } 
     return aggregatedResults; 
    } 
} 

Answer 2

作爲futher改進，你可以考慮使用一個CompletionService 它分離提交和檢索，而不是把所有的未來結果從中你把結果在他們完成訂單隊列的順序..

Answer 3

我可以建議你使用Future.get() with a timeout？

否則它會只需要一個搜索引擎不響應使一切都停止（它甚至不需要是一個搜索引擎的問題，比如說，如果你方有一個網絡問題）