ComplectableFuture # whenComplete wird nicht aufgerufen, wenn thenApply verwendet wird

Question

Ich habe den folgenden Code (resultierend aus my previous question), der eine Aufgabe auf einem Remote-Server plant und dann zur Fertigstellung unter Verwendung von ScheduledExecutorService#scheduleAtFixedRate abfragt. Sobald die Aufgabe abgeschlossen ist, wird das Ergebnis heruntergeladen. Ich möchte eine Future an den Aufrufer zurückgeben, so dass sie entscheiden können, wann und wie lange zu blockieren, und geben Sie ihnen die Option, die Aufgabe abzubrechen.

Mein Problem ist, dass, wenn der Client die Future von der download zurückgegebene Methode storniert, whenComplete Block nicht ausgeführt wird. Wenn ich thenApply entferne, tut es das. Es ist offensichtlich, dass ich etwas falsch verstehe über Future Zusammensetzung ... Was soll ich ändern?

public Future<Object> download(Something something) { 
    String jobId = schedule(something); 
    CompletableFuture<String> job = pollForCompletion(jobId); 
    return job.thenApply(this::downloadResult); 
} 

private CompletableFuture<String> pollForCompletion(String jobId) { 
    ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor(); 
    CompletableFuture<String> completionFuture = new CompletableFuture<>(); 

    ScheduledFuture<?> checkFuture = executor.scheduleAtFixedRate(() -> {   
      if (pollRemoteServer(jobId).equals("COMPLETE")) { 
       completionFuture.complete(jobId); 
      } 
    }, 0, 10, TimeUnit.SECONDS); 
    completionFuture     
      .whenComplete((result, thrown) -> { 
       System.out.println("XXXXXXXXXXX"); //Never happens unless thenApply is removed 
       checkFuture.cancel(true); 
       executor.shutdown(); 
      }); 
    return completionFuture; 
} 

Auf die gleiche Note, wenn ich es tue:

return completionFuture.whenComplete(...) 

statt

completionFuture.whenComplete(...); 
return completionFuture; 

whenComplete führt auch nie. Dies scheint mir sehr widersprüchlich zu sein. Sollte nicht logischerweise die Future zurückgegeben von whenComplete die sein, an der ich mich festhalten sollte?

EDIT:

ich meinen Code geändert, um explizit die Stornorück propagieren. Es ist abscheulich und nicht lesbar, aber es funktioniert und ich konnte nicht einen besseren Weg finden:

public Future<Object> download(Something something) throws ChartDataGenException, Exception { 
     String jobId = schedule(report); 
     CompletableFuture<String> job = pollForCompletion(jobId); 
     CompletableFuture<Object> resulting = job.thenApply(this::download); 
     resulting.whenComplete((result, thrown) -> { 
      if (resulting.isCancelled()) { //the check is not necessary, but communicates the intent better 
       job.cancel(true); 
      } 
     }); 
     return resulting; 
} 

Answer 1

Ihre Struktur ist wie folgt:

  ┌──────────────────┐ 
      │ completionFuture | 
      └──────────────────┘ 
      ↓    ↓ 
    ┌──────────────┐  ┌───────────┐ 
    │ whenComplete |  │ thenApply | 
    └──────────────┘  └───────────┘ 

Also, wenn Sie kündigen die thenApply Zukunft, die ursprüngliche completionFuture Objekt bleibt unberührt, da es nicht von der Stufe thenApply abhängt. Wenn Sie jedoch die Stufe thenApply nicht verketten, geben Sie die ursprüngliche completionFuture Instanz zurück, und das Abbrechen dieser Stufe führt zur Stornierung aller abhängigen Stufen, wodurch die Aktion whenComplete sofort ausgeführt wird.

Aber wenn die Stufe thenApply abgebrochen wird, kann die completionFuture noch abgeschlossen werden, wenn die pollRemoteServer(jobId).equals("COMPLETE") Bedingung erfüllt ist, da diese Abfrage nicht beendet wird. Aber wir kennen die Beziehung jobId = schedule(something) und pollRemoteServer(jobId) nicht. Wenn Ihre Anwendung Zustandsänderungen in einer Art und Weise, dass diese Bedingung kann nie einen Download nach dem Abbrechen, diese Zukunft wird nie abgeschlossen ...

---

In Bezug auf Ihre letzte Frage erfüllt werden, die Zukunft ist „diejenige, die ich festhalten soll? "Es gibt keine Notwendigkeit, eine lineare Kette von Futures zu haben, während die Bequemlichkeitsmethoden von CompletableFuture es einfach machen, eine solche Kette zu erstellen, mehr als oft, es ist die am wenigsten nützliche Sache zu tun, wie Sie einfach ein schreiben könnten Codeblock, wenn Sie eine lineare Abhängigkeit haben. Ihr Modell der Verkettung von zwei unabhängigen Stufen ist richtig, aber die Aufhebung funktioniert nicht durch sie, aber es würde auch nicht durch eine lineare Kette funktionieren.

Wenn Sie die Quellphase abbrechen möchten, benötigen Sie einen Verweis darauf. Wenn Sie jedoch das Ergebnis einer abhängigen Stufe erhalten möchten, benötigen Sie auch eine Referenz auf diese Stufe.