Question

我正在尝试在Scala中使用并发编程。基于this example在此处 StackOverflow，我根据Project Euler的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))
  }
}

结果如下：

max = 10：

单身：（23,31）
游泳池：（23,16）
期货：（23,31）

max = 100：

单身：（2318,33）
游泳池：（2318,31）
期货：（2318,55）

max = 1000：

单身：（233168,42）
游泳池：（233168,111）
期货：（233168,364）

max = 10000：

单身：（23331668,144）
游泳池：（23331668,544）
期货：......我在3分钟后取消了执行

显然我无法正确使用Java和Scala中的并发API。所以我问：我的错误在哪里？使用并发更合适的形式是什么？关于斯卡拉演员？有可能使用它们吗？

Answer 1

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

您的机器有多少个核心？如果你只有一个核心，那么你应该期望时间随着工作线性增加。在运行过程中，您的CPU使用情况如何？这些数字是否可重复？

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

Answer 2

我假设您使用的是Scala 2.7。基本上，filter上的map和Range（1 until max的结果）是非严格的，这意味着它将按需计算，并且每次都会计算你试图访问它的结果。

试试这个，例如：

val y = (1 to 10).filter{x => println("Filtering "+x); x % 2 == 0}.map{x => println("Mapping "+x); x * 2}
println(y(0))
println(y(1))
println(y(2))
println(y(0))

无论如何，结果是您的并行内容正在以串行方式运行。在范围中添加.force，就可以了。

Scala中的并发处理

2 个答案: