Question

我有一个方法需要一系列查询，我需要针对不同的搜索引擎Web API运行它们，例如谷歌或雅虎。为了并行化该过程，每个查询都会生成一个线程，然后在最后join，因为我的应用程序只能在之后继续我有的结果每个查询。我目前有以下几点：

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; } }

最近，我发现Java中有一个用于执行并发作业的 new API。即，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的新手，我想知道在上面的代码中是否有某些东西可以改进，如果它比第一个选项更好（使用{{ 1}}）。我没有探索过一些类，例如Thread等等。我也很乐意听到任何建议。

Answer 1

您的代码有几个问题。

您应该使用ExecutorService.invokeAll（）方法。创建新线程和新线程池的成本可能很高（尽管可能与调用外部搜索引擎无比）。 invokeAll（）可以为你管理线程。
您可能不想混合使用数组和泛型。
您正在调用aggregatedResults.add（）而不是addAll（）。
当它们可能是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

作为进一步改进，您可以考虑使用CompletionService 它将提交和检索的顺序分离，而是将所有未来结果放在一个队列中，从中按照完成顺序获取结果。

Answer 3

我可以建议您使用Future.get() with a timeout吗？

否则它只会让一个搜索引擎无法响应才能停止一切（如果您在最后遇到网络问题，它甚至不需要成为搜索引擎问题）

多线程搜索操作

3 个答案: