いくつかの先物があり、それらのいずれかが失敗するか、すべてが成功するまで待つ必要があるとします。
たとえば:3つの先物がありましょうf1
、f2
、f3
。
場合は
f1
成功し、f2
失敗した私は待たないf3
(と返す失敗をクライアントに)。実行中に
f2
失敗しf1
、f3
まだ実行中の場合、私はそれらを待ちません(そして失敗を返します)f1
成功してからf2
成功した場合、私は待ち続けf3
ます。
どのように実装しますか?
いくつかの先物があり、それらのいずれかが失敗するか、すべてが成功するまで待つ必要があるとします。
たとえば:3つの先物がありましょうf1
、f2
、f3
。
場合はf1
成功し、f2
失敗した私は待たないf3
(と返す失敗をクライアントに)。
実行中にf2
失敗しf1
、f3
まだ実行中の場合、私はそれらを待ちません(そして失敗を返します)
f1
成功してからf2
成功した場合、私は待ち続けf3
ます。
どのように実装しますか?
回答:
代わりに、次のように理解のために使用できます。
val fut1 = Future{...}
val fut2 = Future{...}
val fut3 = Future{...}
val aggFut = for{
f1Result <- fut1
f2Result <- fut2
f3Result <- fut3
} yield (f1Result, f2Result, f3Result)
この例では、先物1、2、3が並行して開始されます。次に、理解のために、結果1、2、3の順に結果が得られるまで待ちます。1または2のいずれかが失敗した場合、3を待つことはもうありません。3つすべてが成功した場合、aggFut
valは3つの先物の結果に対応する3つのスロットを持つタプルを保持します。
ここで、fut2が最初に失敗した場合に待機を停止したい動作が必要な場合は、少し注意が必要です。上記の例では、fut2が失敗したことに気付く前に、fut1が完了するのを待つ必要があります。これを解決するには、次のような方法を試すことができます。
val fut1 = Future{Thread.sleep(3000);1}
val fut2 = Promise.failed(new RuntimeException("boo")).future
val fut3 = Future{Thread.sleep(1000);3}
def processFutures(futures:Map[Int,Future[Int]], values:List[Any], prom:Promise[List[Any]]):Future[List[Any]] = {
val fut = if (futures.size == 1) futures.head._2
else Future.firstCompletedOf(futures.values)
fut onComplete{
case Success(value) if (futures.size == 1)=>
prom.success(value :: values)
case Success(value) =>
processFutures(futures - value, value :: values, prom)
case Failure(ex) => prom.failure(ex)
}
prom.future
}
val aggFut = processFutures(Map(1 -> fut1, 2 -> fut2, 3 -> fut3), List(), Promise[List[Any]]())
aggFut onComplete{
case value => println(value)
}
これは正しく機能するようになりましたが、問題は、正常に完了Future
したMap
ときにどちらを削除するかを知っていることに起因します。結果を、その結果を生み出したFutureと適切に関連付ける方法がある限り、このようなものは機能します。完了した先物をマップから再帰的に削除Future.firstCompletedOf
し、残りがFutures
なくなるまで残りを呼び出し、途中で結果を収集します。それはきれいではありませんが、あなたが話している振る舞いが本当に必要な場合は、これ、または同様のものが機能する可能性があります。
fut2
以前に失敗した場合はどうなりますfut1
か?fut1
その場合でも待ちますか?私たちがそうするなら、それは私が望んでいるものではありません。
onFailure
ハンドラーをインストールして、fut2
すばやく失敗し、onSuccess
onaggFut
をインストールして成功を処理できます。aggFut
暗黙の成功fut2
は正常に完了したため、呼び出されるハンドラーは1つだけです。
promiseを使用して、最初の失敗または最後に完了した集約された成功のいずれかをそれに送信できます。
def sequenceOrBailOut[A, M[_] <: TraversableOnce[_]](in: M[Future[A]] with TraversableOnce[Future[A]])(implicit cbf: CanBuildFrom[M[Future[A]], A, M[A]], executor: ExecutionContext): Future[M[A]] = {
val p = Promise[M[A]]()
// the first Future to fail completes the promise
in.foreach(_.onFailure{case i => p.tryFailure(i)})
// if the whole sequence succeeds (i.e. no failures)
// then the promise is completed with the aggregated success
Future.sequence(in).foreach(p trySuccess _)
p.future
}
次に、ブロックしたい場合、または単にそれを他の何かに入れたい場合はAwait
、その結果を処理できます。Future
map
理解の場合との違いは、ここでは最初に失敗したエラーが発生するのに対し、理解の場合は、入力コレクションの走査順序で最初のエラーが発生することです(別のエラーが最初に失敗した場合でも)。例えば:
val f1 = Future { Thread.sleep(1000) ; 5 / 0 }
val f2 = Future { 5 }
val f3 = Future { None.get }
Future.sequence(List(f1,f2,f3)).onFailure{case i => println(i)}
// this waits one second, then prints "java.lang.ArithmeticException: / by zero"
// the first to fail in traversal order
そして:
val f1 = Future { Thread.sleep(1000) ; 5 / 0 }
val f2 = Future { 5 }
val f3 = Future { None.get }
sequenceOrBailOut(List(f1,f2,f3)).onFailure{case i => println(i)}
// this immediately prints "java.util.NoSuchElementException: None.get"
// the 'actual' first to fail (usually...)
// and it returns early (it does not wait 1 sec)
これは、アクターを使用しないソリューションです。
import scala.util._
import scala.concurrent._
import java.util.concurrent.atomic.AtomicInteger
// Nondeterministic.
// If any failure, return it immediately, else return the final success.
def allSucceed[T](fs: Future[T]*): Future[T] = {
val remaining = new AtomicInteger(fs.length)
val p = promise[T]
fs foreach {
_ onComplete {
case s @ Success(_) => {
if (remaining.decrementAndGet() == 0) {
// Arbitrarily return the final success
p tryComplete s
}
}
case f @ Failure(_) => {
p tryComplete f
}
}
}
p.future
}
あなたは先物だけでこれを行うことができます。これが1つの実装です。実行が早期に終了しないことに注意してください!その場合、より洗練された何かをする必要があります(そしておそらく自分で中断を実装します)。ただし、機能しないものを待ち続けたくない場合は、最初の処理が完了するのを待ち続け、何も残っていないか、例外が発生したときに停止することが重要です。
import scala.annotation.tailrec
import scala.util.{Try, Success, Failure}
import scala.concurrent._
import scala.concurrent.duration.Duration
import ExecutionContext.Implicits.global
@tailrec def awaitSuccess[A](fs: Seq[Future[A]], done: Seq[A] = Seq()):
Either[Throwable, Seq[A]] = {
val first = Future.firstCompletedOf(fs)
Await.ready(first, Duration.Inf).value match {
case None => awaitSuccess(fs, done) // Shouldn't happen!
case Some(Failure(e)) => Left(e)
case Some(Success(_)) =>
val (complete, running) = fs.partition(_.isCompleted)
val answers = complete.flatMap(_.value)
answers.find(_.isFailure) match {
case Some(Failure(e)) => Left(e)
case _ =>
if (running.length > 0) awaitSuccess(running, answers.map(_.get) ++: done)
else Right( answers.map(_.get) ++: done )
}
}
}
すべてが正常に機能する場合の動作例を次に示します。
scala> awaitSuccess(Seq(Future{ println("Hi!") },
Future{ Thread.sleep(1000); println("Fancy meeting you here!") },
Future{ Thread.sleep(2000); println("Bye!") }
))
Hi!
Fancy meeting you here!
Bye!
res1: Either[Throwable,Seq[Unit]] = Right(List((), (), ()))
しかし、何かがうまくいかないとき:
scala> awaitSuccess(Seq(Future{ println("Hi!") },
Future{ Thread.sleep(1000); throw new Exception("boo"); () },
Future{ Thread.sleep(2000); println("Bye!") }
))
Hi!
res2: Either[Throwable,Seq[Unit]] = Left(java.lang.Exception: boo)
scala> Bye!
この目的のために、私はAkkaアクターを使用します。理解のためとは異なり、先物のいずれかが失敗するとすぐに失敗するので、その意味でもう少し効率的です。
class ResultCombiner(futs: Future[_]*) extends Actor {
var origSender: ActorRef = null
var futsRemaining: Set[Future[_]] = futs.toSet
override def receive = {
case () =>
origSender = sender
for(f <- futs)
f.onComplete(result => self ! if(result.isSuccess) f else false)
case false =>
origSender ! SomethingFailed
case f: Future[_] =>
futsRemaining -= f
if(futsRemaining.isEmpty) origSender ! EverythingSucceeded
}
}
sealed trait Result
case object SomethingFailed extends Result
case object EverythingSucceeded extends Result
次に、アクターを作成し、それにメッセージを送信して(返信の送信先がわかるように)、返信を待ちます。
val actor = actorSystem.actorOf(Props(new ResultCombiner(f1, f2, f3)))
try {
val f4: Future[Result] = actor ? ()
implicit val timeout = new Timeout(30 seconds) // or whatever
Await.result(f4, timeout.duration).asInstanceOf[Result] match {
case SomethingFailed => println("Oh noes!")
case EverythingSucceeded => println("It all worked!")
}
} finally {
// Avoid memory leaks: destroy the actor
actor ! PoisonPill
}
この質問には回答しましたが、ここに値クラスソリューションがないため、値クラスソリューション(値クラスは2.10で追加されました)を投稿しています。お気軽にご批判ください。
implicit class Sugar_PimpMyFuture[T](val self: Future[T]) extends AnyVal {
def concurrently = ConcurrentFuture(self)
}
case class ConcurrentFuture[A](future: Future[A]) extends AnyVal {
def map[B](f: Future[A] => Future[B]) : ConcurrentFuture[B] = ConcurrentFuture(f(future))
def flatMap[B](f: Future[A] => ConcurrentFuture[B]) : ConcurrentFuture[B] = concurrentFutureFlatMap(this, f) // work around no nested class in value class
}
def concurrentFutureFlatMap[A,B](outer: ConcurrentFuture[A], f: Future[A] => ConcurrentFuture[B]) : ConcurrentFuture[B] = {
val p = Promise[B]()
val inner = f(outer.future)
inner.future onFailure { case t => p.tryFailure(t) }
outer.future onFailure { case t => p.tryFailure(t) }
inner.future onSuccess { case b => p.trySuccess(b) }
ConcurrentFuture(p.future)
}
ConcurrentFutureは、デフォルトのFuture map / flatMapをdo-this-then-thatからcombine-all-and-fail-if-any-failに変更するオーバーヘッドのないFutureラッパーです。使用法:
def func1 : Future[Int] = Future { println("f1!");throw new RuntimeException; 1 }
def func2 : Future[String] = Future { Thread.sleep(2000);println("f2!");"f2" }
def func3 : Future[Double] = Future { Thread.sleep(2000);println("f3!");42.0 }
val f : Future[(Int,String,Double)] = {
for {
f1 <- func1.concurrently
f2 <- func2.concurrently
f3 <- func3.concurrently
} yield for {
v1 <- f1
v2 <- f2
v3 <- f3
} yield (v1,v2,v3)
}.future
f.onFailure { case t => println("future failed $t") }
上記の例では、f1、f2、およびf3が同時に実行され、いずれかが任意の順序で失敗すると、タプルの将来はすぐに失敗します。
TwitterのFutureAPIをチェックアウトすることをお勧めします。特にFuture.collectメソッド。それはまさにあなたが望むことをします: https //twitter.github.io/scala_school/finagle.html
ソースコードFuture.scalaはここから入手できます:https: //github.com/twitter/util/blob/master/util-core/src/main/scala/com/twitter/util/Future.scala
あなたはこれを使うことができます:
val l = List(1, 6, 8)
val f = l.map{
i => future {
println("future " +i)
Thread.sleep(i* 1000)
if (i == 12)
throw new Exception("6 is not legal.")
i
}
}
val f1 = Future.sequence(f)
f1 onSuccess{
case l => {
logInfo("onSuccess")
l.foreach(i => {
logInfo("h : " + i)
})
}
}
f1 onFailure{
case l => {
logInfo("onFailure")
}