Wie kann ich warten, für ein Scala Zukunft der onSuccess-callback-zu vervollständigen?

In Scala, die ich verwenden kann Await zu warten, für eine Zukunft zu vervollständigen. Allerdings, wenn ich mich registriert habe ein callback ausführen nach Abschluss der Zukunft aus, wie kann ich das warten nicht nur für die Zukunft abgeschlossen, sondern auch für den Rückruf zu beenden?

Hier ist ein minimales, aber komplettes Programm, um 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 die Ausgabe:

The program waited patiently for this callback to finish.

Statt, es gibt keine Ausgabe; das Programm beendet wird, bevor der Rückruf beendet ist.

Bitte beachten Sie, dass dies nicht das gleiche problem als erwartet für die Zukunft zu ergänzen, die zuvor bereits beantwortet wurde bei diese Frage.

InformationsquelleAutor Daniel Li | 2016-01-15

19

Verwenden Sie nicht einen onSuccess-callback, sondern die Nebenwirkung, die in eine Zukunft.anzeigen aufrufen. Auf diese Weise haben Sie eine Zukunft[Einheit] zum Einsatz Erwarten.
```
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 ausführen möchten, eine Nebenwirkung, die nur bei Erfolg (wie in deinem Beispiel), Karte geeignet ist. Wenn Sie ausführen möchten, eine Nebenwirkung auch im Falle des Scheiterns, dann ist die richtige Methode zu verwenden. Sehen Sie diese post von Roland Kuhn auf der scala-user.

Bitte auch, nicht verwenden Sie Thread.Schlaf irgendwo in der Nähe von Produktions-code.

Es gibt keine 2-futures, wenn Sie das wegwerfen der Wert der ersten. Könnte genauso gut einfach alles in eine einzige Zukunft.
Dies war zu bleiben, so nah wie möglich an den angegebenen code. In einer realen Anwendung, die erste Zukunft produzieren würde, ein Wert, den Sie tatsächlich nutzen.
Wenn map und flatMap erreichen die gleichen Dinge wie onSuccess (und mehr, da können Sie Werte zurückgeben), warum haben die onSuccess in der API überhaupt? Ist es nur für die Symmetrie mit onFailure? Oder sind onSuccess und onFailure lower-level-Konstrukte, auf die map und flatMap umgesetzt werden, unter der Haube?
Untersuchen Sie die Quelle für das Zukunft zeigt, dass dies nicht der Fall zu sein scheint.

InformationsquelleAutor Rüdiger Klaehn

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

Drucke:

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

Mithilfe verspricht, ist auch klar:

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

Drucke:

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

Ich denke, verspricht ein low-level-API, die sollte nicht verwendet werden, wenn es vermieden werden kann. Also das erste Beispiel für die Verwendung dann besser ist.
Genau. Versprechen ist was andThen verwendet unter der Haube die Synchronisierung der onComplete handler.
In dem Beispiel mit Promise, wenn Sie schlafen, bevor Sie drucken This program ... es wird nie gedruckt. Ich denke, das Beispiel hat das gleiche problem wie die ursprüngliche Frage - gibt es nichts zu warten, für p.future.onSuccess.

InformationsquelleAutor yǝsʞǝlA

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.