为什么使用复制比串行执行慢得多？

Question

我有点问题。我想使用 scala.concurrent.ops.replicate 来并行化我的程序。但我发现，算法实际上变得慢得多。 所以我写了一个小测试，仍然得到相同的结果。所以他们来了。

序列号：大约需要 63 秒才能完成

object SerTest {
  def main(args: Array[String]) {
      for(x <- 1 to 10){
        for(i <- 1 to 4) {
          for(j <- 1 to 100000) {
            val a = BigInt(j).isProbablePrime(1000)
            if(!a && j == 100000) println(i + " is ready")}}}}}

并发代码：大约需要 161 秒才能完成

object ParTest {
  def main(args: Array[String]) {
      for(x <- 1 to 10){
        replicate(1,5) { i =>
          for(j <- 1 to 100000) {
            val a = BigInt(j).isProbablePrime(1000)
            if(!a && j == 100000) println(i + " is ready")}}}}}

那么，我犯的完全明显且令人尴尬的错误在哪里？ :)

编辑：哦，我在四核 CPU 上运行它。所以它实际上应该更快:)

Edit2：由于 Kevin Wright 的回答，我稍微更改了程序以延长运行时间。

Answer 1

查看您的示例代码，我猜您正在从命令行直接跳转到 main 方法。这是在 Java 中进行微分析的绝对最糟糕的方法！

您应该首先运行您的测试几次（在同一个 VM 调用中），至少足以让 JVM 在您思考之前已经正确预热并运行 30 秒。 em> 关于开始测量任何东西。这将确保它运行的是已编译（而非解释）的代码，并且已经过全面优化。

您还需要了解启动线程的成本。对于短时间运行的循环，这将是一个令人望而却步的开销，并且会比循环本身消耗更多的时间！

更新

以下定义来自 ops.scala：

val defaultRunner: FutureTaskRunner = TaskRunners.threadRunner
def spawn(p: => Unit)(implicit runner: TaskRunner = defaultRunner): Unit = {...}
def replicate(start: Int, end: Int)(p: Int => Unit) {...}

所以实际使用的跑步者是作为隐式注入的， 或默认为TaskRunners.threadRunner

您可以尝试将其更改为使用线程池，方法是在您的代码前加上：

implicit val runner = TaskRunners.threadPoolRunner

或者我相信以下方法也可以：

import concurrent.TaskRunners.threadPoolRunner

看看有没有区别

---

三思而后行……

我认为该参数实际上不会传递给对spawn 的嵌套调用，如果您自己复制该方法可能会更好（我目前在邮件列表上对此进行了查询）。

为了您的方便，这里是完整的、可怕的、荣耀的方法：

def replicate(start: Int, end: Int)(p: Int => Unit) {
  if (start == end) 
    ()
  else if (start + 1 == end)
    p(start)
  else {
    val mid = (start + end) / 2
    spawn { replicate(start, mid)(p) }
    replicate(mid, end)(p)
  }
}

（你仍然需要定义隐式运行器...）

Answer 2

查看 BigInteger.isProbablePrime 的源代码（BigInt 委托给 java 库）。它正在做大量的 new BigInteger() 因为那是一个不可变的类。

我的猜测是内存分配导致过多的争用从并行化中受益。您可以通过用一个简单的计算（例如将 100MM 数字相乘）代替您的素数测试来确认。或者，使用 var longs 而不是 BigInt 重写主要测试。

此外，ops.replicate 将操作派生到新线程中，而不是利用某种线程池。线程创建有一定的开销，但在这种情况下不足以成为问题。我个人更喜欢使用更强大的 java.util.concurrent 库。