Multithread-Suche

Question

Ich habe eine Methode, die eine Reihe von Abfragen benötigt, und ich muss sie gegen verschiedene Suchmaschinen-Web-APIs ausführen, wie Google oder Yahoo. Um den Prozess parallel zu machen, wird für jede Abfrage ein Thread erzeugt, der dann am Ende join ed wird, da meine Anwendung nur weiter nach ich habe die Ergebnisse alle abfragen kann. Im Moment habe ich etwas in dieser Richtung:

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

Kürzlich habe ich festgestellt, dass es eine neue API in Java für die gleichzeitige Arbeit tun. Nämlich die Callable Schnittstelle, FutureTask und ExecutorService. Ich habe mich gefragt, ob diese neue API die ist, die verwendet werden sollte, und wenn sie effizienter als die traditionellen sind, Runnable und Thread.

Nach dieser neuen API zu studieren, kam ich mit dem folgenden Code (vereinfachte Version) bis:

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

Ich bin neu in dieser Gleichzeitigkeit API, und ich würde gerne wissen, ob es etwas gibt, das kann be verbesserte in dem obigen Code, und wenn es besser ist als die erste Option (mit Thread). Es gibt einige Klassen, die ich nicht untersucht habe, wie FutureTask und so weiter. Ich würde auch gerne einen Rat dazu hören.

Answer 1

Mehrere Probleme mit Ihrem Code.

1. Sie sollten wahrscheinlich die ExecutorService.invokeAll() -Methode verwenden. Die Kosten für das Erstellen neuer Threads und eines neuen Thread-Pools können beträchtlich sein (obwohl dies möglicherweise nicht mit dem Aufruf externer Suchmaschinen verglichen wird). invokeAll() kann die Threads für Sie verwalten.
2. Vermutlich möchten Sie Arrays und Generika nicht mischen.
3. Sie rufen aggregatedResults.add() anstelle von addAll() auf.
4. Sie müssen keine Mitgliedsvariablen verwenden, wenn sie für den Funktionsaufruf queryAll() lokal sein könnten.

Also, so etwas wie die folgenden funktionieren sollte:

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

Als weitere Verbesserung, Sie CompletionService Es abkoppelt in mit der Reihenfolge der Einreichung und Abrufen alle, anstatt Platzierung der zukünftigen Ergebnisse auf einer Warteschlange aussehen könnte, aus dem Sie die Ergebnisse in der Reihenfolge nehmen sie abgeschlossen sind ..

Answer 3

Kann ich schlage vor, Sie Future.get() with a timeout verwenden?

Sonst wird es dauern nur eine Suchmaschine nicht mehr reagiert wird alles zum Stillstand zu bringen (es braucht nicht einmal eine Suchmaschine Problem zu sein, wenn, sagen wir, Sie ein Netzwerkproblem an Ihrem Ende haben)