recorrer - scala ejemplos

Cómo resolver una lista de futuros en Scala

Question

Tengo una llamada que devuelve un futuro. Sin embargo, necesito hacer n llamadas para volver a n futuros. Me pregunto cómo lograría que los futuros se resolvieran antes de continuar (sin bloquear el servidor)

Por ejemplo,

while(counter < numCalls){
val future = call(counter)
future.map{ x =>
//do stuff
}
counter += 1
}
//Now I want to execute code here after ALL the futures are resolved without
//blocking the server

Answer 1

Puede usar Future.sequence(futureList) para convertir una List[Future[X]] en un Future[List[X]] . Y dado que este último es solo un Future simple, puede esperar a que termine con la ayuda de Await.ready o ayudantes similares.

Así que tendrías que mantener una lista de los futuros que generas. Algo como:

val futures = new ListBuffer[Future[X]]
while(counter < numCalls) {
val future = call(counter)
futures += future
future.map { x =>
//do stuff
}
counter += 1
}
val f = Future.sequence(futures.toList)
Await.ready(f, Duration.Inf)

que también podrías escribir como:

val futures = (1 to numCalls).map(counter => {
f = call(counter)
f.map(x => ...)
f
})
Await.ready(Future.sequence(futures), Duration.Inf)

Answer 2

Supongo que usted quiere hacer algo después de que se terminen los futuros, por ejemplo. ¿Una devolución de llamada, sin bloquear la llamada original? Entonces deberías hacer algo como esto:

val futures = for (...) yield {
future {
...
}
}
val f = Future sequence futures.toList
f onComplete {
case Success(results) => for (result <- results) doSomething(result)
case Failure(t) => println("An error has occured: " + t.getMessage)
}

http://docs.scala-lang.org/overviews/core/futures.html

Así que no bloquea con una llamada en espera, pero aún espera a que se completen todos los futuros y luego haga algo en todos los resultados. Los aspectos clave es usar Future.sequence para unir muchos futuros juntos y luego usar una devolución de llamada para actuar sobre el resultado.

Answer 3

Un poco más funcional:

val futures = for {
c <- 0 until 10
} yield {
val f = call(c)
f onSuccess {
case x =>
// Do your future stuff with x
}
f
}
Future.sequence(futures)