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)