performance - Scala 中的并发处理

Question

我正在尝试在 Scala 中使用并发编程。位于 this example在此处
StackOverflow，我基于Problem 1做了一个程序欧拉计划。
我尝试了三种方法:第一种是简单的执行，没有并行性。这
第二个通过 Executors 和 Callables 使用 java.util.concurrency API。第三个，基于上面提到的页面，使用 scala.Futures。我的目标是比较执行时间。

这是代码:

package sandbox

import java.util.concurrent._
import scala.actors._

object TestPool {

  def eval(n: Int): Boolean = (n % 3 == 0) || (n % 5 == 0)

  def runSingle(max: Int): Int = (1 until max).filter(eval(_)).foldLeft(0)(_ + _)

  def runPool(max: Int): Int = {

    def getCallable(i: Int): Callable[Boolean] = new Callable[Boolean] { def call = eval(i) }

    val pool = Executors.newFixedThreadPool(5)
    val result = (1 until max).filter(i => pool.submit(getCallable(i)).get).foldLeft(0)(_ + _)
    pool.shutdown
    pool.awaitTermination(Math.MAX_LONG, TimeUnit.SECONDS)

    result
  }

  def runFutures(max: Int): Int = (1 until max).filter(i => Futures.future(eval(i)).apply).foldLeft(0)(_ + _)

  /**
   * f is the function to be runned. it returns a Tuple2 containing the sum and the 
   * execution time.
   */
  def test(max: Int, f: Int => Int): (Int, Long) = {
    val t0 = System.currentTimeMillis
    val result = f(max)
    val deltaT = System.currentTimeMillis - t0

    (result, deltaT)
  }


  def main(args : Array[String]) : Unit = {
    val max = 10000

    println("Single : " + test(max, runSingle))
    println("Pool   : " + test(max, runPool))
    println("Futures: " + test(max, runFutures))
  }
}

这些是结果:

最大值 = 10:

单: (23,31)

池 : (23,16)

future :(23,31)

最大值 = 100:

单: (2318,33)

池:(2318,31)

future :(2318,55)

最大值 = 1000:

单例:(233168,42)

池:(233168,111)

future :(233168,364)

最大值 = 10000:

单例:(23331668,144)

池:(23331668,544)

future :...我在 3 分钟后取消了执行

显然我无法正确使用 Java 和 Scala 的并发 API。所以我问:
我的错误在哪里？使用并发的更合适的形式是什么？
关于 Scala Actor ？可以使用它们吗？

Answer 1

你期待什么结果？您是否期望这些方法中的一种比其他方法表现得更好？您是否希望程序针对不同的执行方法进行不同的扩展？

你的机器有多少核？如果您只有一个内核，那么您应该预计时间会随着要做的工作而线性增加。在运行过程中，您的 CPU 使用情况如何？数字可重复吗？

您还没有考虑 JVM 热点预热时间的影响，这可能会导致像这样的微基准测试出现实质性问题。