2

类 TestClassString 返回一个 java.util.List of Strings

TestViewPerformance 对象记录了调用TestViewController.iterateList 方法所花费的时间。

在 iterateList 中，当并行性被移除时，运行这个小程序所花费的时间至少快 100 毫秒：

mySeq.par 到 mySeq

我意识到这里有用于测量 scala 性能的基准测试工具：http: //docs.scala-lang.org/overviews/parallel-collections/performance.html

但是我仍然希望这个程序使用基于当前毫秒时间的并行性运行得更快吗？.par 循环中的所有代码是否分布在多个内核上？

这是整个代码：

package testpackage

import java.util.Calendar

object TestViewPerformance {

  def main(args:Array[String]) = {

      val before = Calendar.getInstance().getTimeInMillis()

      val testViewController = new TestViewController();
      val testClassString : TestClassString = new TestClassString()

      val folderList = testClassString.getStringList()
      var buffer = new scala.collection.mutable.ListBuffer[String]
      val seq = scala.collection.JavaConversions.asScalaBuffer(folderList);

      /*
       * this method (iterateList) is where the parallelism occurs
       */
      testViewController.iterateList(seq)

      val after = Calendar.getInstance().getTimeInMillis()

      println(before)
      println(after)
      println(after-before)

  }

  class TestViewController {

      def iterateList(mySeq : Seq[String]) = {

        for (seqVal<- mySeq) {
            if(seqVal.equalsIgnoreCase("test")){            

            }
        }   
}

}

}

package testpackage;

import java.util.ArrayList;
import java.util.List;

public class TestClassString {

    public List<String> getStringList(){

        List<String> l = new ArrayList<String>();

        for(int i = 0; i < 1000000; ++i){
            String test = ""+Math.random();
            l.add(test);
        } 

        return l;
    }

}
4

2 回答 2

8

因为您的基准测试正在测量线程切换和量子波动的开销。至少添加Thread.sleep(1)到您的循环中，看看会发生什么：

scala> val strings = (1 to 10000).map(_ + Math.random().toString)
strings: scala.collection.immutable.IndexedSeq[String] = Vector(10.8907863042670979, 20.2871957696184603, 30.20011325237932742, 40.7490949002788928, 50.5073228980632211...
scala> val time = System.currentTimeMillis; 
       | for (str <- strings.par) {Thread.sleep(1)}; 
       | System.currentTimeMillis - time
res0: Long = 1398

scala> val time = System.currentTimeMillis; 
       | for (str <- strings) {Thread.sleep(1)}; 
       | System.currentTimeMillis - time
res3: Long = 11129
于 2013-02-23T11:16:44.367 回答
3

这可能是因为每次迭代中的大部分时间都用于打印到System.out，这是一个同步操作，因此不可并行化。因此，启动线程、调度它们和同步它们所产生的成本使得并行迭代比顺序迭代慢。

于 2013-02-23T10:44:04.480 回答