「sequence」という言葉は、アクションのseriesが次々と続くことを意味します。
_object Test {
def main(args: Array[String]) {
def producer() = {
val list = Seq(
future { println("startFirst"); Thread.sleep(3000); println("stopFirst") },
future { println("startSecond"); Thread.sleep(1000); println("stopSecond") }
)
Future.sequence(list)
}
Await.result(producer, Duration.Inf)
}
}
_
したがって、このプログラムが印刷することを期待しています:_startFirst stopFirst startSecond stopSecond
_
またはさらに:_startSecond stopSecond startFirst stopFirst
_
(そうではありません):_startFirst startSecond stopSecond stopFirst
_
このメソッドがFuture.parallel()
と呼ばれないのはなぜですか?そして、先物のSeq
内のすべての先物が(並列ではなく)連続的にトリガーされることを保証するために何を使うべきですか?
先物は同時に開始されているため、同時に実行されています:)。それらを順番に実行するには、flatMapを使用する必要があります。
Future { println("startFirst");
Thread.sleep(3000);
println("stopFirst")
}.flatMap{
_ => Future {
println("startSecond");
Thread.sleep(1000);
println("stopSecond")
}
}
Future.sequenceはSeq[Future[T]] => Future[Seq[T]]
これは、すでに開始されているすべての先物の結果を収集し、それを未来に置くことを意味します。
元のFuture.sequenceを少し変更すると、将来の実行がシリアル化されます。
def seq[A, M[X] <: TraversableOnce[X]](in: M[() => Future[A]])(implicit cbf: CanBuildFrom[M[()=>Future[A]], A, M[A]], executor: ExecutionContext): Future[M[A]] = {
in.foldLeft(Future.successful(cbf(in))) {
(fr, ffa) => for (r <- fr; a <- ffa()) yield (r += a)
} map (_.result())
}
コードは次のようになります。
object Test {
def main(args: Array[String]) {
def producer() = {
val list = Seq(
{() => future { println("startFirst"); Thread.sleep(3000); println("stopFirst") }},
{() => future { println("startSecond"); Thread.sleep(1000); println("stopSecond") }}
)
FutureExt.seq(list)
}
Await.result(producer, Duration.Inf)
}
}
これは元のコードと非常に似ており、元のFuture.sequence()と同じ結果コレクションを持ちます。
線形化:
import scala.concurrent._
import scala.collection.mutable.Builder
import scala.collection.generic.CanBuildFrom
import language.higherKinds
/**
* Linearize asynchronously applies a given function in-order to a sequence of values, producing a Future with the result of the function applications.
* Execution of subsequent entries will be aborted if an exception is thrown in the application of the function.
*/
def linearize[T, U, C[T] <: Traversable[T]](s: C[T])(f: T => U)(implicit cbf: CanBuildFrom[C[T], U, C[U]], e: ExecutionContext): Future[C[U]] = {
def next(i: Iterator[T], b: Builder[U, C[U]]): Future[C[U]] = if(!i.hasNext) Future successful b.result else Future { b += f(i.next()) } flatMap { b => next(i, b) }
next(s.toIterator, cbf(s))
}
scala> linearize(1 to 100)(_.toString) foreach println
scala> Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100)
いくつかの値のシーケンスがあり、それらをFuture
にマップし、それらを連続して実行する場合:
import scala.concurrent.ExecutionContext.Implicits.global
implicit class SeqExtension[A](s: Seq[A]) {
def foldLeftToFuture[B](initial: B)(f: (B, A) => Future[B])(implicit ec: ExecutionContext): Future[B] =
s.foldLeft(Future(initial))((future, item) => future.flatMap(f(_, item)))
def mapInSeries[B](f: A => Future[B])(implicit ec: ExecutionContext): Future[Seq[B]] =
s.foldLeftToFuture(Seq[B]())((seq, item) => f(item).map(seq :+ _))
}
val stringsFuture: Future[Seq[String]] = Seq(1, 2, 3).mapInSeries[String](i => Future(i.toString))
val strings = Await.result(stringsFuture, Duration.Inf) // List("1", "2", "3")
または、{..} yieldブロックに使用してFutureのシーケンスを取得できます。 Future.sequence Seq [Future]をFuture [Seq]に変換します