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
Vous devez vous connecter pour publier un commentaire.
Vous pouvez même faire ce bloc asynchrone et chaque demande attend son maximum de temps. Si il y a trop de threads, probablement un seul thread qui effectue la vérification pour d'autres futures à l'aide de Akka du
system scheduler
. @Senia a répondu ci-dessous sur celui-ci.Vous pouvez créer
future
qui retourne des résultats de tous les 3 à terme à l'aide deflatMap
ou de compréhension:Si vous utilisez
akka
vous pouvez remplir votre avenir avec la valeur par défaut après un délai d'attente:Je voudrais éviter d'utiliser
Await.result
depuis que utilise un thread juste pour le blocage. Une option à mettre en œuvre délai d'attente pour les contrats à terme serait celui-ci:Cela crée une promesse qui sera complété par un futur ou par un résultat par défaut après le délai spécifié, selon la première éventualité.
Pour exécuter les requêtes simultanément vous ferait comme suit: