多线程搜索操作

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？

否则它会只需要一个搜索引擎不响应使一切都停止（它甚至不需要是一个搜索引擎的问题，比如说，如果你方有一个网络问题）