Scala-未来和性能上的简单映射

我使用下面的代码片段对scala

Future

s进行了一些性能分析

class Container(ec: ExecutionContext) {

  implicit val executionContext = ec

  def getInts: Future[Vector[Int]] = {
    Future {
      (1 to 100).toVector
    }
  }
}

implicit val ec = new ExecutionContext {
  val threadPool = Executors.newFixedThreadPool(100)
  // val threadPool = Executors.newFixedThreadPool(2)
  // I tried with both of the above threadPools

  def execute(runnable: Runnable) {
    threadPool.submit(runnable)
  }

  def reportFailure(t: Throwable) {}
}

考虑以下琐碎的片段

片段1

val container = new Container(ec)
val allIntsF = container.getInts

for {
  allInts <- allIntsF
} yield {
  val allIntsTransformed = allInts.map(i => 2 * i / 3)
  val allIntsFiltered = allIntsTransformed.filter(i => i > 50)
  allIntsFiltered.sum / allInts.length
}

val容器=新容器（ec）
val allIntsF=container.getInts
为了{
联合体2*i/3）
val allIntsFiltered=allIntsTransformed.filter（i=>i>50）
allIntsFiltered.sum/allInts.length
}

片段2

val container = new Container(ec)
val allIntsF = container.getInts
val allIntsTransformedF = allIntsF.map(v => v.map(i => 2 * i / 3))
val allIntsFilteredF = allIntsTransformedF.map(v => v.filter(i => i > 50))

for {
  allInts <- allIntsF
  allIntsTransformed <- allIntsTransformedF
  allIntsFiltered <- allIntsFilteredF
  // Assume that all 3 of these are needed for some calculation
} yield {
  allIntsFiltered.sum / allInts.length
}

val容器=新容器（ec）
val allIntsF=container.getInts
val allIntsTransformedF=allIntsF.map（v=>v.map（i=>2*i/3））
val allIntsFilteredF=allIntsTransformedF.map（v=>v.filter（i=>i>50））
为了{
allInts你能分享一下测量结果吗？还有，你是如何做基准测试的？仅仅一次迭代并不是一个很好的比较基础，尽管从直觉上看，变体#1应该更快（在变体2中，您在
allIntsF
上映射了两次，一次在
allIntsF.map中进行理解，另一次在
allIntsF.map中……
，对于
allIntsTransformed
，同样的情况也会发生，因此从逻辑上讲，它必须稍微慢一点，但如果您有大量的未来，这可能会增加更多的开销）尝试使用替换模型（通过使用一系列
flatMap
s和
map
）重写理解的你会发现变体#2中存在重复。我运行了100次，取了平均时间。我稍后会发布测量结果。同意@NaderHadjiGhanbari的观点：将操作移动到代码段#2中以便于理解，与代码段#1相比增加了2个平面图。此外，如果我理解正确，这将实例化一个ThreadPool，其中只有一个未来，即一个线程运行。更大的线程池只会增加更多的管理开销，不会增加任何计算“能力”/“并行化”您是如何实际“运行100次并取平均值”的？这个问题的答案在这里实际上非常重要。