Futures ausgeführt, um, obwohl es keine Abhängigkeit ist

Question

ich den folgenden Code haben:

def f1: Future[Unit] = Future { 
    Thread sleep 10000 
    println("1") 
    1 
    } 

    def f2: Future[Unit] = Future { 
    Thread sleep 5 
    println("2") 
    } 

    def f3(x: Unit, y: Unit): Future[Unit] = Future { 
    Thread sleep 10 
    println("3") 
    } 

    def main(args: Array[String]): Unit = { 

    val f = for { 
     r1 <- f1 
     r2 <- f2 
     r3 <- f3(r1, r2) 
    } yield r3 

    Await.result(f, Duration.Inf) 
    } 

f3 hängt von f2 und f1

es keine Abhängigkeit zwischen f1 und f2

Wenn ich laufen der Code, den ich bekomme:

1 
2 
3 

Ich möchte f1 und f2 parallel laufen aber vor f3.

2 
1 
3 

Wie kann ich das tun: So weil f2 vor f1 die Ausgabe sollte beendet werden soll?

Answer 1

val f = f1 zip f2 flatMap f3.tupled 

Oder, wenn Sie aus irgendeinem Grund auf mit for Verständnis bestehen:

val f = for { 
    (r1, r2) <- f1 zip f2 
    r3 <- f3(r1, r2) 
} yield r3 

Answer 2

Ihr für Verständnis sie zwingt, in dieser Reihenfolge auszuführen. Das Verständnis ist eigentlich syntaktischer Zucker für die Funktionen map, flatMap und withFilter. In Ihrem Fall, nur flatMap. Es wird zu diesem Ausdruck erweitert werden:

f1.flatMap(r1 => f2.flatMap(r2 => f3(r1, r2))) 

Wie man hier sehen kann, die Funktion zu f1.flatMap weitergegeben wird erst f1 Ausführung ist abgeschlossen bezeichnet werden.

Ein einfacher Weg, um dieses Problem zu lösen, wäre die Zukunft vor dem für Verständnis zu instanziiert, wie folgt aus:

val future1 = f1 
val future2 = f2 

val f = for { 
    r1 <- future1 
    r2 <- future2 
    r3 <- f3(r1, r2) 
} yield r3