性能 – Scala中的并发处理

2023年11月12日 208次阅读

我正在尝试在
Scala中使用并发编程.基于
this example在这里

StackOverflow,我根据项目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.所以我问：
我的错误在哪里？使用并发更合适的形式是什么？
关于斯卡拉演员？有可能使用它们吗？

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

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

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

点赞