Scala 执行按顺序返回未来的函数序列

我有一系列返回未来的函数。我希望按顺序执行它们，即在第一个函数future完成后，执行下一个函数，依此类推。有办法吗

---

操作：Seq[（）=>未来[单位]]

我认为这应该可以做到：

import scala.concurrent.{Await, Future}
import scala.concurrent.duration.Duration

def runSequentially(ops: Seq[() => Future[Unit]]): Unit = {
  ops.foreach(f => Await.result(f(), Duration.Inf))
}

---

如果您希望等待的时间少于

Duration.Inf

，或者在出现故障时停止，那么应该很容易做到。

我相信这应该可以做到：

import scala.concurrent.{Await, Future}
import scala.concurrent.duration.Duration

def runSequentially(ops: Seq[() => Future[Unit]]): Unit = {
  ops.foreach(f => Await.result(f(), Duration.Inf))
}

---

如果您想等待的时间少于

Duration.Inf

，或者在失败时停止，应该很容易做到。

您可以使用

foldLeft

和

flatMap将所有期货组合成一个期货：

def executeSequentially(ops: Seq[() => Future[Unit]])(
  implicit exec: ExecutionContext
): Future[Unit] =
  ops.foldLeft(Future.successful(()))((cur, next) => cur.flatMap(_ => next()))

foldLeft
确保从左到右的顺序，并且
flatMap
提供顺序执行。函数是通过
ExecutionContext
执行的，因此依次调用
executese
并不是阻塞。您可以在需要时添加回调或等待生成的
未来

如果您使用的是Twitter
Future
s，那么我猜您不需要传递
ExecutionContext
，但是
foldLeft
和
flatMap
的总体思路应该仍然有效。
您可以将所有的Future与
foldLeft
和
flatMap
组合成一个未来：

def executeSequentially(ops: Seq[() => Future[Unit]])(
  implicit exec: ExecutionContext
): Future[Unit] =
  ops.foldLeft(Future.successful(()))((cur, next) => cur.flatMap(_ => next()))

foldLeft
确保从左到右的顺序，并且
flatMap
提供顺序执行。函数是通过
ExecutionContext
执行的，因此依次调用
executese
并不是阻塞。您可以在需要时添加回调或等待生成的
未来

如果您使用的是Twitter
Future
s，那么我猜您不需要传递
ExecutionContext
，但是
foldLeft
和
flatMap
的总体思路应该仍然有效。
如果给定一个Seq[Future[t]]，您可以将其转换为未来[Seq[t]]，如下：

Val a: Seq[Future[T]] = ???

val resut: Future[Seq[T]] = Future.sequence(a)

比上面少一点样板：）
如果给定一个Seq[Future[T]]，您可以将其转换为Future[Seq[T]]，如下所示：

Val a: Seq[Future[T]] = ???

val resut: Future[Seq[T]] = Future.sequence(a)

比上面少了一点样板：）