Exécuter plusieurs contrats à terme en parallèle, renvoyer la valeur par défaut au timeout

J'ai à l'exécution de plusieurs contrats à terme en parallèle et le programme ne devrait pas se bloquer ou se bloquer.

Pour l'instant j'attends sur les contrats à terme, un par un, et utiliser la valeur de repli si il y a TimeoutException.

val future1 = //start future1
val future2 = //start future2
val future3 = //start future3
//<- at this point all 3 futures are running
//waits for maximum of timeout1 seconds
val res1 = toFallback(future1, timeout1, Map[String, Int]())
//.. timeout2 seconds 
val res2 = toFallback(future2, timeout2, List[Int]())
//... timeout3 seconds
val res3 = toFallback(future3, timeout3, Map[String, BigInt]()) 
def toFallback[T](f: Future[T], to: Int, default: T) = {
Try(Await.result(f, to seconds))
.recover { case to: TimeoutException => default }
}

Que je peux voir, le temps d'attente maximal de cet extrait est timeout1 + timeout2 + timeout3

Ma question est: comment puis-je attendre sur tous ces contrats à terme à la fois, donc je peux réduire le temps d'attente pour max(timeout1, timeout2, timeout3)?

EDIT: En fin de compte j'ai utilisé la modification de @Jatin et @senia réponses:

private def composeWaitingFuture[T](fut: Future[T], 
timeout: Int, default: T) =
future { Await.result(fut, timeout seconds) } recover {
case e: Exception => default
}

et, plus tard, elle est utilisée comme suit:

//starts futures immediately and waits for maximum of timeoutX seconds
val res1 = composeWaitingFuture(future1, timeout1, Map[String, Int]())
val res2 = composeWaitingFuture(future2, timeout2, List[Int]())
val res3 = composeWaitingFuture(future3, timeout3, Map[String, BigInt]()) 
//takes the maximum of max(timeout1, timeout2, timeout3) to complete
val combinedFuture =
for {
r1 <- res1
r2 <- res2
r3 <- res3
} yield (r1, r2, r3)

et plus tard, j'ai utiliser combinedFuture comme je l'entends.

source d'informationauteur Zotov | 2013-07-04