スカラ未来のonSuccessコールバックが完了するのを待つ方法を教えてください。

Question

Scalaでは、私はAwaitを使用して、将来の完了を待つことができます。しかし、私がその未来を完了するとコールバックを登録すると、未来が完了するのを待つだけでなく、そのコールバックが終了するまで待つことができますか？ここで

は、問題を説明するための最小限のが、完全なプログラムです：

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

私は出力があることを期待：

The program waited patiently for this callback to finish. 

その代わり、出力がありません。プログラムはコールバックが終了する前に終了します。

これは、先にthis questionで回答されている、今後の完了を待っているのと同じ問題ではないことに注意してください。

Answer 1

onSuccessコールバックを使用しないでください。代わりに、Future.map呼び出しで副作用を行います。そうすれば、Awaitを使用する未来の[ユニット]ができます。

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

成功例（例のように）にのみ副作用を実行する場合は、mapが適切です。障害が発生した場合にも副作用を実行するには、正しい方法を使用してください。 scala-userのRoland Kuhnのpostを参照してください。

また、を入力しないでくださいを使用すると、プロダクションコードのどこかでThread.sleepを使用できます。

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

プリント：

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

約束を使用すると、より明確である：

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

プリント：

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