Opération de recherche multithread

Question

J'ai une méthode qui prend un tableau de requêtes, et j'ai besoin de les exécuter sur différentes API Web de moteur de recherche, comme Google ou Yahoo. Afin de paralléliser le processus, un thread est généré pour chaque requête, qui est ensuite join ed à la fin, puisque mon application ne peut que continuer après J'ai les résultats de toutes les requêtes. J'ai actuellement quelque chose le long de ces lignes:

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

Récemment, j'ai trouvé qu'il ya une nouvelle API Java en pour faire des travaux simultanés. A savoir, l'interface Callable, FutureTask et ExecutorService. Je me demandais si cette nouvelle API est celle qui devrait être utilisée, et si elles sont plus efficaces que les traditionnelles, Runnable et Thread.

Après avoir étudié cette nouvelle API, je suis venu avec le code suivant (version simplifiée):

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

Je suis nouveau à cette API d'accès concurrentiel, et je voudrais savoir s'il y a quelque chose qui peut être amélioré dans le code ci-dessus, et si c'est mieux que la première option (en utilisant Thread). Il y a des classes que je n'ai pas explorées, telles que FutureTask, et cetera. J'aimerais avoir des conseils à ce sujet également.

Answer 1

Plusieurs problèmes avec votre code.

1. Vous devriez probablement utiliser la méthode ExecutorService.invokeAll(). Le coût de création de nouveaux threads et d'un nouveau pool de threads peut être important (même s'il n'est peut-être pas comparé à l'appel de moteurs de recherche externes). invokeAll() peut gérer les threads pour vous.
2. Vous ne voulez probablement pas mélanger les baies et les génériques.
3. Vous appelez aggregatedResults.add() au lieu de addAll().
4. Vous n'avez pas besoin d'utiliser des variables membres lorsqu'elles peuvent être locales à l'appel de la fonction queryAll().

Donc, quelque chose comme ce qui suit devrait fonctionner:

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

Comme une amélioration futher, vous pouvez regarder dans un CompletionService Il découple l'ordre de la soumission et la récupération, au lieu de placer tous les résultats futurs sur une file d'attente à partir de laquelle vous prenez des résultats dans l'ordre où ils sont terminés ..

Answer 3

Puis-je vous suggère d'utiliser Future.get() with a timeout?

Sinon, il ne vous prendra un moteur de recherche étant insensible à apporter tout un coup d'arrêt (il n'a même pas besoin d'être un problème de moteur de recherche si, par exemple, vous avez un problème de réseau à votre fin)