Jak mogę czekać na zakończenie wywołania zwrotnego onSuccess w Scala?

Question

W Scali mogę użyć Await, aby poczekać na ukończenie przyszłości. Jeśli jednak zarejestrowałem wywołanie zwrotne, które będzie uruchamiane po zakończeniu tej przyszłości, jak mogę czekać nie tylko na zakończenie tej usługi, ale także na zakończenie tego połączenia zwrotnego?

Tutaj jest minimalny, ale kompletny program do zilustrowania problemu:

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

Spodziewam się, że wyjście będzie:

The program waited patiently for this callback to finish. 

Zamiast tego, nie ma wyjścia; program kończy działanie przed zakończeniem oddzwaniania.

Należy pamiętać, że nie jest to ten sam problem, co oczekiwanie na ułożenie w przyszłości, na co wcześniej udzielono odpowiedzi pod numerem this question.

Answer 1

Nie używaj wywołania zwrotnego onSukces, ale zamiast tego wywołuj efekt uboczny w wywołaniu Future.map. W ten sposób masz Future [Unit], aby używać Await na.

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

Uwaga: jeśli chcesz wywołać efekt uboczny tylko w przypadku powodzenia (jak w twoim przykładzie), mapa jest odpowiednia. Jeśli chcesz wykonać efekt uboczny również w przypadku awarii, a następnie jest właściwą metodą użycia. Zobacz to post od Rolanda Kuhna na scala-user.

Również, proszę nie używać Thread.sleep w dowolnym miejscu w pobliżu kodu produkcyjnego.

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") 
    } 
} 

drukuje:

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

Korzystanie obietnic jest jeszcze bardziej oczywiste:

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") 
    } 
} 

drukuje:

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