尝试顺序执行期货。怎么了？

Question

我正在尝试执行按顺序返回 Future 的函数

所以，我有一个收藏

  val in = Seq(1, 1, -1, -2, 3, -4, 5, 6, 7, -1, -2, -9, 1, 2, 2)

以及处理此集合中每个 int 的函数

  def intToFuture(int: Int): Future[Int] = {
    Future {
      println(s"Running function $int")
      Thread.sleep(1500)
      int * 100
    }
  }

我需要实现按并行处理部分处理收集的逻辑。 获取前 n 个元素，将每个元素并行乘以 100，然后获取接下来的 n 个元素并执行相同操作......等等。

我所做的（在我阅读了这个网站上的一些帖子之后）是，我实现了两个功能

1)处理一批计算

  def processBatch(ints: Seq[Int])(f: Int => Future[Int]): Future[Seq[Int]] = {
    Future.sequence(ints.map(f))
  }

2)和第二个，适用于迭代处理

  def batchTraverse(in: Seq[Int], size: Int)(f: Int => Future[Int]): Future[Seq[Int]] = {
    val grs = in.grouped(size).toList
    def loop(l: Seq[Seq[Int]]): Future[Seq[Int]] = {
      l match {
        case Nil =>
          Future.successful(l.flatten)//? flatten
        case head :: tail =>
          println("head="+head)
          processBatch(head)(f).flatMap{
            s => loop(tail).map{ t =>
              s.appendedAll(t)
            }
          }
      }
    }
    loop(grs)
  }

然后开始

  val fs: Future[Seq[Int]] = batchTraverse(in, 3)(intToFuture)

  fs.onComplete{
    f => println(f)
  }

结果只进行了一次迭代，我哪里弄错了？

Answer 1

您的函数实际上似乎工作正常，可能发生的是您的程序在未来有机会完成之前终止，因此您只看到第一次迭代。通过在您的代码中添加等待，我能够让事情正常工作。

import scala.concurrent._
import scala.concurrent.duration._

val fs: Future[Seq[Int]] = batchTraverse(in, 3)(intToFuture)

fs.onComplete{
  f => println(f)
}

Await.result(fs, Duration.Inf)

您可能需要小于Duration.Inf 的持续时间，因为这将永远等待未来完成。这样做我能够得到以下输出：

head=List(1, 1, -1)
Running function 1
Running function 1
Running function -1
head=List(-2, 3, -4)
Running function -4
Running function 3
Running function -2
head=List(5, 6, 7)
Running function 7
Running function 6
Running function 5
head=List(-1, -2, -9)
Running function -9
Running function -2
Running function -1
head=List(1, 2, 2)
Running function 2
Running function 2
Running function 1
Success(List(100, 100, -100, -200, 300, -400, 500, 600, 700, -100, -200, -900, 100, 200, 200))