Warum tut das dann der Zukunft nicht Kette das Ergebnis?

Den andThen Bedeutung, die ich gelernt, aus dieser Antwort ist eine Funktion Komponist.

Sagen, dass 

f andThen g andThen h

wird gleich

h(g(f(x)))

Dies impliziert die h function erhalten input von g(f(x))

Aber für die andThen im Future alle die Schließung der folgenden dann erhält immer das Ergebnis von der ursprünglichen Future.

Future{
    1
}.andThen{ case Success(x) =>
    println(x) //print 1
    Thread.sleep(2000)
    x * 2
}.andThen{ case Success(x) =>
    println(x) //print 1
    Thread.sleep(2000)
    x * 2
}

vergleichen, um

val func: Function1[Int, Int] = { x: Int =>
  x
}.andThen { y =>
  println(y) //print 1
  y * 2
}.andThen { z =>
  println(z) //print 2
  z * 2
}
func(1)

Was ist der Grund der Zukunft::dann(s), alle erhalten das gleiche Ergebnis von der ursprünglichen Zukunft anstelle der Verkettung Zukunft? Ich habe festgestellt, dass diese verkettete dann sequentiell abgearbeitet werden, so kann der Grund nicht sein für parallel Zweck.

InformationsquelleAutor Chen OT | 2015-06-05
  1. 22

    scala.concurrent.Future ist konzipiert als Kompromiss zweier asynchroner Ansätze:

    1. Objekt-orientierte Beobachter ermöglicht die Bindung von asynchronen Handler
    2. Funktionale Monade das reichhaltige funktionale Zusammensetzung Fähigkeiten.

    Lesen Zukunft.dann's docs:

    Gilt die side-effecting-Funktion, um das Ergebnis mit der Zukunft und
    gibt eine neue Zukunft mit dem Ergebnis dieser Zukunft.

    So andThen ist wahrscheinlich aus OOP-Universum. Zu gewinnen ähnlichen ähnliches Ergebnis zu Function1.andThen könnten Sie S)(implicitexecutor:scala.gleichzeitige.ExecutionContext):scala.gleichzeitige.Zukunft[S]" >map Methode :

    Future(1).map {_ * 2}.map {_ * 2}

    andThen unterscheidet sich von onComplete mit einer Kleinigkeit: die daraus resultierende Zukunft der andThen noch zurückgeben gleiche Ergebnis, aber warten, bis geliefert Beobachter zurück oder werfen etwas. Das ist, warum es geschrieben steht in den docs:

    Diese Methode erlaubt es, durchzusetzen, dass die callbacks werden ausgeführt
    angegebenen Reihenfolge.

    Beachten Sie auch die Dritte Zeile von docs:

    Beachten Sie, dass, wenn einer der verketteten dann Rückrufe löst eine Ausnahme aus,
    diese Ausnahme nicht weitergegeben an die nachfolgenden dann Rückrufe.
    Stattdessen werden die nachfolgenden dann Rückrufe gegeben, den ursprünglichen Wert
    von dieser Zukunft.

    Damit es " komplett nichts zu tun mit neuen Future's Ergebnis. Konnte ja nicht verderben, es mit es ownt Ausnahme. Diese andThen und onComplete nur sequenzielle und parallele Bindung von Beobachtern.

    • Kann ich sagen, Es ist eine andere version onComplete aber wieder "diese", so dass es binden kann mehrere "Beobachter" callback-Handler in Verkettung Stil?
    • Ja. Ziemlich viel
    • mit einem Unterschied. Ich werde dies hinzufügen asnwer
    • aktualisiert
    • oh oh! Die Kette-können dann, anders onComplete Rückkehr Einheit, impliziert diese dann Verschlüsse werden nacheinander ausgeführt
    • onSuccess, onFailure, onComplete, und dann sind eine Gruppe von Funktionen, die für die Bindung Observer callback-Funktion, die kann ein Nebeneffekt Verfahren. Und eine andere Gruppe von map, flatMap, fallbackTo, erholen, ... werden zu einem späteren Komponisten Kette und propagieren die Zukunft führen zu der Rute. Bin ich im Recht?
    • Lassen Sie uns weiter, diese Diskussion im chat.

    InformationsquelleAutor Odomontois
  2. 1

    Lassen Sie mich zusammenfassen diese nette Diskussion.

    Sagen, wir haben tf: Future[T] =..., und zwei Funktionen, f: T => U und g: U => V

    Können wir tun vf: Future[V] = tf map f map g, wievf: Future[V] = tf map (f andThen g)

    In einem anderen use-case, dass fp: PartialFunction[T, U] und gp: PartialFunction[U, V],
    können wir tf1: Future[T] = tf andThen fp andThen gp - diese partiellen Funktionen aufgerufen werden, auf dem Wert, der tf produziert, mit außerhalb keine Wirkung, nur Nebenwirkungen passieren. Diese Sequenz wartet fp vor dem Aufruf gp.

    Eine weitere operation, onComplete, funktioniert wie folgt: nachdem f: Try[T] => U, wird der Anruf tf onComplete f rufen f auch wenn die Zukunft endete mit einer Fehlermeldung, das Ergebnis tf onComplete f ist der Typ Unit.

    Auch, wenn Ihre Funktion f produziert eine Future, müssen Sie flatMap.

    InformationsquelleAutor Vlad Patryshev
Schreibe einen Kommentar