Warte auf jede Zukunft in einer Liste <Future> getan werden

Question

Ich rufe eine Methode, die eine Future, einmal für jedes Element in einer List<Principal> zurückgibt, so dass ich mit einer List<Future<UserRecord>> enden.

Die Methode, die Future zurückgibt, ist Bibliothekscode und ich habe keine Kontrolle darüber, wie dieser Code ausgeführt wird, alles, was ich habe, ist die Future.

Ich möchte warten, bis alle Future s (Erfolg oder Misserfolg) abgeschlossen sind, bevor Sie fortfahren.

Gibt es eine bessere Art und Weise so, als dies zu tun:

List<Principal> users = new ArrayList<>(); 
// Fill users 
List<Future<UserRecord>> futures = getAllTheFutures(users); 
List<UserRecord> results = new ArrayList<>(futures.size()); 
boolean[] taskCompleted = new boolean[futures.size()]; 
for (int j = 0; j < taskCompleted.length; j++) { 
    taskCompleted[j] = false; 
} 
do { 
    for (int i = 0; i < futures.size(); i++) { 
     if (!taskCompleted[i]) { 
      try { 
       results.add(i, futures.get(i).get(20, TimeUnit.MILLISECONDS)); 
       taskCompleted[i] = true; 
      } catch (TimeoutException e) { 
       // Do nothing 
      } catch (InterruptedException | ExecutionException e) { 
       // Handle appropriately, then... 
       taskCompleted[i] = true; 
      } 
     } 
    } 
} while (allNotCompleted(taskCompleted)); 

Für die Neugierigen:

private boolean allNotCompleted(boolean[] completed) { 
    for (boolean b : completed) { 
     if (!b) 
      return true; 
    } 
    return false; 
} 

Anders als in dieser Antwort auf Waiting on a list of Future ich nicht die Kontrolle über den Code haben, schafft die Future s.

Answer 1

Ihr Code kann vereinfacht werden viel. Eine äquivalente Version könnte wie folgt geschrieben werden, es sei denn, Sie haben Anforderungen, die Sie in der Frage nicht angegeben haben.

List<Principal> users = // fill users 
List<Future<UserRecord>> futures = getAllTheFutures(users); 
List<UserRecord> results = new ArrayList<>(); 

for (int i = 0; i < futures.size(); i++) { 
     try { 
      results.add(futures.get(i)); 
     } catch (InterruptedException | ExecutionException e) { 
      // Handle appropriately, results.add(null) or just leave it out 
     } 
    } 
} 

Answer 2

Angenommen, Ihr Zweck ist es, eine Funktion zu entwickeln, führen Sie alle Futures aus, bis alles erfolgreich abgeschlossen ist. Da Sie Java 8 verwenden, habe ich hier einige Java 8-Syntaxen verwendet.

Ich verwendete java.util.concurrent.CopyOnWriteArrayList, um gleichzeitige Probleme zu vermeiden. Aber es sieht dort nicht notwendig aus. Sie können auch mit den üblichen java.util.List testen. Ich habe den Code allerdings nicht getestet.

Answer 3

Sie könnten einfach eine reduktive Liste machen; Entfernen erfolgreicher Antworten aus Ihrer Liste und Iterieren bis leer.

List<Principal> users = // fill users 
List<Future<UserRecord>> futures = getAllTheFutures(users); 
List<UserRecord> results = new ArrayList<>(); 

for (int i = 0; i < futures.size(); i++) { 
     try { 
      results.add(futures.get(i).get(<how long you want before your application throws exception>)); 

     } 
     catch (InterruptedException | ExecutionException e) { 
      // Handle appropriately, results.add(null) or just leave it out 
     } 
     catch (TimeoutException timeoutEx) { 
      // If the Future retrieval timed out you can handle here 
     } 

    } 
} 

Da Ihre Absicht ist, ein „Set“ von Jobs zu sammeln, bevor voran, zu warten, bis Sie eine Rückkehr auf Thread-Index X in diesem Fall bekommen den letzten zurück Thread eine Zeitkosten (in etwa) geben.

Oder, wenn Sie alle Themen in der Menge zum Abbruch planen wer nicht, können Sie Java 8 CompletableFuture

CompletableFuture[] cfs = futures.toArray(new CompletableFuture[futures.size()]); 

    return CompletableFuture.allOf(cfs) 
      .thenApply(() -> futures.stream() 
            .map(CompletableFuture::join) 
            .collect(Collectors.toList()) 
      ); 

• Kredit Kayaman für vereinfachte Codebasis verwenden.