Les contrats à terme sont très pratiques, mais en pratique, vous aurez peut-être besoin de garanties quant à leur exécution. Par exemple, considérons:Utilisation pratique des contrats à terme? C'est à dire, comment les tuer?
import scala.actors.Futures._
def slowFn(time:Int) = {
Thread.sleep(time * 1000)
println("%d second fn done".format(time))
}
val fs = List(future(slowFn(2)), future(slowFn(10)))
awaitAll(5000, fs:_*)
println("5 second expiration. Continuing.")
Thread.sleep(12000) // ie more calculations
println("done with everything")
L'idée est de lancer certaines fonctions de fonctionnement lent en parallèle. Mais nous ne voudrions pas rester éternellement si les fonctions exécutées par les futurs ne reviennent pas. Nous utilisons donc awaitAll() pour mettre un timeout sur les futures. Mais si vous exécutez le code, vous voyez que le délai de 5 secondes expire, mais le futur de 10 secondes continue de s'exécuter et revient plus tard. Le timeout ne tue pas le futur. cela limite simplement l'attente de la jointure.
Alors, comment tuer un avenir après une période de timeout? Il semble que les contrats à terme ne peuvent pas être utilisés dans la pratique, à moins que vous ne soyez certain qu'ils reviendront dans un laps de temps connu. Sinon, vous risquez de perdre des threads dans le pool de threads pour des contrats à terme sans fin jusqu'à ce qu'il n'en reste plus. Donc, les questions sont: Comment tuer les futurs? Quels sont les modèles d'utilisation prévus pour les contrats à terme étant donné ces risques?
Mais puisque le problème d'arrêt n'a pas encore été résolu :), vous n'avez aucune garantie qu'une fonction reviendra. Ainsi, les contrats à terme peuvent ne jamais revenir. Donc la question originale reste ... Point pris à propos de l'utilisation de awaitAll() pour obtenir des résultats partiels. Cela ressemble à un modèle d'utilisation: passez dans une classe qui enregistre des résultats partiels à mesure qu'ils sont générés, puis utilisez la minuterie pour les extraire. – DrGary