【发布时间】：2011-12-23 02:09:53
【问题描述】：
我针对 10,000,000 个元素运行了一组性能基准测试，我发现每次实施的结果差异很大。
谁能解释为什么创建 Range.ByOne 会产生比简单的基元数组更好的性能，但将相同的范围转换为列表会导致比最坏情况下更差的性能？
创建 10,000,000 个元素，并打印出以 1,000,000 为模的元素。 JVM 大小始终设置为相同的最小值和最大值：-Xms?m -Xmx?m
import java.util.concurrent.TimeUnit
import java.util.concurrent.TimeUnit._
object LightAndFastRange extends App {
def chrono[A](f: => A, timeUnit: TimeUnit = MILLISECONDS): (A,Long) = {
val start = System.nanoTime()
val result: A = f
val end = System.nanoTime()
(result, timeUnit.convert(end-start, NANOSECONDS))
}
def millions(): List[Int] = (0 to 10000000).filter(_ % 1000000 == 0).toList
val results = chrono(millions())
results._1.foreach(x => println ("x: " + x))
println("Time: " + results._2);
}
JVM 大小为 27m 需要 141 毫秒
相比之下，转换为 List 会显着影响性能：
import java.util.concurrent.TimeUnit
import java.util.concurrent.TimeUnit._
object LargeLinkedList extends App {
def chrono[A](f: => A, timeUnit: TimeUnit = MILLISECONDS): (A,Long) = {
val start = System.nanoTime()
val result: A = f
val end = System.nanoTime()
(result, timeUnit.convert(end-start, NANOSECONDS))
}
val results = chrono((0 to 10000000).toList.filter(_ % 1000000 == 0))
results._1.foreach(x => println ("x: " + x))
println("Time: " + results._2)
}
460-455 m 需要 8514-10896 ms
相比之下，这个 Java 实现使用了一个原语数组
import static java.util.concurrent.TimeUnit.*;
public class LargePrimitiveArray {
public static void main(String[] args){
long start = System.nanoTime();
int[] elements = new int[10000000];
for(int i = 0; i < 10000000; i++){
elements[i] = i;
}
for(int i = 0; i < 10000000; i++){
if(elements[i] % 1000000 == 0) {
System.out.println("x: " + elements[i]);
}
}
long end = System.nanoTime();
System.out.println("Time: " + MILLISECONDS.convert(end-start, NANOSECONDS));
}
}
JVM 大小为 59m 需要 116ms
Java 整数列表
import java.util.List;
import java.util.ArrayList;
import static java.util.concurrent.TimeUnit.*;
public class LargeArrayList {
public static void main(String[] args){
long start = System.nanoTime();
List<Integer> elements = new ArrayList<Integer>();
for(int i = 0; i < 10000000; i++){
elements.add(i);
}
for(Integer x: elements){
if(x % 1000000 == 0) {
System.out.println("x: " + x);
}
}
long end = System.nanoTime();
System.out.println("Time: " + MILLISECONDS.convert(end-start, NANOSECONDS));
}
}
JVM 大小为 283m 需要 3993 毫秒
我的问题是，为什么第一个示例如此高效，而第二个示例却受到如此严重的影响。我尝试创建视图，但未能成功再现该范围的性能优势。
在 Mac OS X Snow Leopard 上运行的所有测试， Java 6u26 64 位服务器 斯卡拉 2.9.1.final
编辑：
为了完成，这里是使用 LinkedList 的实际实现（这在空间方面比 ArrayList 更公平，因为正如正确指出的那样，scala 的列表是链接的）
import java.util.List;
import java.util.LinkedList;
import static java.util.concurrent.TimeUnit.*;
public class LargeLinkedList {
public static void main(String[] args){
LargeLinkedList test = new LargeLinkedList();
long start = System.nanoTime();
List<Integer> elements = test.createElements();
test.findElementsToPrint(elements);
long end = System.nanoTime();
System.out.println("Time: " + MILLISECONDS.convert(end-start, NANOSECONDS));
}
private List<Integer> createElements(){
List<Integer> elements = new LinkedList<Integer>();
for(int i = 0; i < 10000000; i++){
elements.add(i);
}
return elements;
}
private void findElementsToPrint(List<Integer> elements){
for(Integer x: elements){
if(x % 1000000 == 0) {
System.out.println("x: " + x);
}
}
}
}
480-460 mbs 需要 3621-6749 毫秒。这更符合第二个 scala 示例的性能。
最后，一个 LargeArrayBuffer
import collection.mutable.ArrayBuffer
import java.util.concurrent.TimeUnit
import java.util.concurrent.TimeUnit._
object LargeArrayBuffer extends App {
def chrono[A](f: => A, timeUnit: TimeUnit = MILLISECONDS): (A,Long) = {
val start = System.nanoTime()
val result: A = f
val end = System.nanoTime()
(result, timeUnit.convert(end-start, NANOSECONDS))
}
def millions(): List[Int] = {
val size = 10000000
var items = new ArrayBuffer[Int](size)
(0 to size).foreach (items += _)
items.filter(_ % 1000000 == 0).toList
}
val results = chrono(millions())
results._1.foreach(x => println ("x: " + x))
println("Time: " + results._2);
}
大约需要 2145 毫秒和 375 mb
非常感谢您的回答。
【问题讨论】：
-
请注意，Java 的
LinkedList是双向链接的，因此每个单元格除了 Scala 的尾部引用外，还有一个反向引用。 -
无需借助 Java 代码来使用原语。
Array[Int]将在幕后使用原语。等效代码应该和 Java 版本的速度一样。 -
我想知道你为什么用米来衡量 JVM 的大小...... :-)
标签： java performance scala collections range