Wie warte ich darauf, dass ein onSuccess-Rückruf von Scala future abgeschlossen wird?

Question

In Scala kann ich Await verwenden, um auf eine Zukunft zu warten, um abzuschließen. Wenn ich jedoch nach Abschluss dieser Zukunft einen Rückruf registriert habe, wie kann ich dann nicht nur auf die Fertigstellung der Zukunft warten, sondern auch darauf, dass dieser Rückruf beendet wird?

Hier ist ein minimal, aber vollständiges Programm, das Problem zu veranschaulichen:

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.duration.Duration 
import scala.concurrent.{ Await, Future } 

object Main { 
    def main(args: Array[String]): Unit = { 
    val f: Future[Int] = Future(0) 
    f.onSuccess { case _ => 
     Thread.sleep(10000) 
     println("The program waited patiently for this callback to finish.") 
    } 

    // This waits for `f` to complete but doesn't wait for the callback 
    // to finish running. 
    Await.ready(f, Duration.Inf) 
    } 
} 

erwarte ich, dass der Ausgang sein:

The program waited patiently for this callback to finish. 

Stattdessen gibt es keine Ausgabe; Das Programm wird beendet, bevor der Rückruf abgeschlossen ist.

Bitte beachten Sie, dass dies nicht das gleiche Problem ist wie das Warten auf eine Zukunft, die zuvor unter this question beantwortet wurde.

Answer 1

Verwenden Sie keinen onSuccess-Rückruf, sondern den Nebeneffekt in einem Future.map-Aufruf. Auf diese Weise haben Sie eine Zukunft [Einheit], auf die Sie warten können.

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.duration.Duration 
import scala.concurrent.{ Await, Future } 

object Main { 
    def main(args: Array[String]): Unit = { 
    val f: Future[Int] = Future(0) 
    val f2: Future[Unit] = f.map { x => 
     Thread.sleep(10000) 
     println("The program waited patiently for this callback to finish.") 
    } 

    Await.ready(f2, Duration.Inf) 
    } 
} 

Beachten Sie, dass, wenn Sie nur eine Nebenwirkung ausgeführt werden sollen im Erfolgsfall (wie in Ihrem Beispiel), ist Karte angebracht. Wenn Sie einen Nebeneffekt auch im Falle eines Fehlers ausführen möchten, und dann ist die richtige Methode zu verwenden. Sehen Sie diese post von Roland Kuhn auf Scala-Benutzer.

Auch bitte nicht Verwenden Sie Thread.sleep überall in der Nähe von Produktionscode.

Answer 2

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.duration.Duration 
import scala.concurrent.{ Await, Future } 
import scala.util._ 

object Main { 
    def main(args: Array[String]): Unit = { 
    val f1: Future[Int] = Future(0) 
    val f2 = f1 andThen { 
     case Success(v) => 
     Thread.sleep(10000) 
     println("The program waited patiently for this callback to finish.") 
     case Failure(e) => 
     println(e) 
    } 

    Await.ready(f1, Duration.Inf) 
    println("F1 is COMPLETED") 
    Await.ready(f2, Duration.Inf) 
    println("F2 is COMPLETED") 
    } 
} 

druckt:

F1 is COMPLETED 
The program waited patiently for this callback to finish. 
F2 is COMPLETED 

Mit Versprechen ist noch deutlicher:

import scala.concurrent.ExecutionContext.Implicits.global 
import scala.concurrent.duration.Duration 
import scala.concurrent._ 
import scala.util._ 

object Main { 
    def main(args: Array[String]): Unit = { 
    val f: Future[Int] = Future(0) 
    val p = Promise[Unit]() 
    p.future.onSuccess { case _ => 
     println("The program waited patiently for this callback to finish.") 
    } 
    f.onSuccess { case _ => 
     Thread.sleep(10000) 
     p.success(()) 
    } 

    Await.ready(f, Duration.Inf) 
    println("F is COMPLETED") 
    Await.ready(p.future, Duration.Inf) 
    println("P is COMPLETED") 
    } 
} 

druckt:

F is COMPLETED 
P is COMPLETED 
The program waited patiently for this callback to finish.