2

我想运行我未来的电话 n 次，例如 5。未来的“执行”将需要一些时间，我只想在前一个完成时调用新的。就像是：

def fun(times: Int): Future[AnyRef] = {
   def _fun(times: Int) = {
      createFuture()
   }

    (1 to times).foldLeft(_fun)((a,b) => {
      println(s"Fun: $b of $times")
      a.flatMap(_ => _fun)
    })
}

所以我想一一调用“_fun”函数n次。“createFuture()”需要一些时间，所以在前一个未来完成之前不应再次调用“_fun”。另外，我想创建一个非阻塞解决方案。目前，此代码无需等待先前的未来结束即可执行。

任何想法如何使它工作？

感谢您的回答！

4

2 回答 2

2

在不了解您希望最终未来返回的确切内容（我将只返回最后完成的未来的结果）的情况下，您可以尝试这样的事情：

def fun(times: Int): Future[AnyRef] = {
  val prom = Promise[AnyRef]()
  def _fun(t: Int) {

    val fut = createFuture()  
    fut onComplete {
      case Failure(ex) => prom.failure(ex)
      case Success(result) if t >= times => prom.success(result)
      case Success(result) => _fun(t + 1)
    }

  }
  _fun(1)

  prom.future
}

这是一种递归解决方案，它将在完成时将期货链接在一起，当达到最大次数时停止链接。这段代码并不完美，但肯定传达了一种可能的解决方案，以确保在前一个 future 成功完成之前不会触发连续的 future。

于 2013-10-08T13:51:15.267 回答
0

我认为如果您使用 flatMap 使其递归会更好。

假设您将 createFuture 定义为：

def createFuture() = Future( println("Create future"))

我们可以创建一个函数来组合 createFuture 的结果：

   def compose(f: () => Future[Unit])(b: Future[Unit]) = b.flatMap(_ => f())

然后你可以将 fun 定义为：

 def fun(n : Int) = {
     def nTimes(n : Int, f : Future[Unit] => Future[Unit], acc : Future[Unit]) = if (n == 0) acc else nTimes(n-1,f,f(acc))
     nTimes(n,compose(createFuture),Future())
 }
于 2013-10-08T15:05:15.193 回答