我编写了一些java类来评估/演示不同的排序算法。但是当我运行我的演示类时，我感到困惑。希望你们能给我一个解释。 （这个问题不是作业。）
首先，我列出一些与此问题相关的代码。
AbstractDemo
public abstract class AbstractDemo {
protected final int BIG_ARRAY_SIZE = 20000;
protected final int SMALL_ARRAY_SIZE = 14;
protected Stopwatch stopwatch = new Stopwatch();
public final void doDemo() {
prepareDemo();
specificDemo();
}
protected abstract void prepareDemo();
protected abstract void specificDemo();
protected final void printInfo(final String text) {
System.out.println(text);
}
}
SortingDemo
public class SortingDemo extends AbstractDemo {
private static final String FMT = "%-10s| %-21s| %7s ms.";
private static final String SPL = AlgUtil.lineSeparator('-', 45);
private static final String SPLT = AlgUtil.lineSeparator('=', 45);
private int[] data;
private final List<Sorting> demoList = new LinkedList<Sorting>();
@Override
protected void specificDemo() {
int[] testData;
//*** this comment is interesting!!! for (int x = 1; x < 6; x++) {
printInfo(String.format("Sorting %7s elements", data.length));
printInfo(SPLT);
for (final Sorting sort : demoList) {
// here I made a copy of the original Array, avoid to sort an already sorted array.
testData = new int[data.length];
System.arraycopy(data, 0, testData, 0, data.length);
stopwatch.start();
// sort
sort.sort(testData);
stopwatch.stop();
printInfo(String.format(FMT, sort.getBigO(), sort.getClass().getSimpleName(), stopwatch.read()));
printInfo(SPL);
testData = null;
stopwatch.reset();
}
//}
}
@Override
protected void prepareDemo() {
data = AlgUtil.getRandomIntArray(BIG_ARRAY_SIZE, BIG_ARRAY_SIZE * 5, false);
demoList.add(new InsertionSort());
demoList.add(new SelectionSort());
demoList.add(new BubbleSort());
demoList.add(new MergeSort()); //here is interesting too
demoList.add(new OptimizedMergeSort());
}
public static void main(final String[] args) {
final AbstractDemo sortingDemo = new SortingDemo();
sortingDemo.doDemo();
}
}
秒表
public class Stopwatch {
private boolean running;
private long startTime;
private long elapsedMillisec;
public void start() {
if (!running) {
this.startTime = System.currentTimeMillis();
running = true;
} else {
throw new IllegalStateException("the stopwatch is already running");
}
}
public void stop() {
if (running) {
elapsedMillisec = System.currentTimeMillis() - startTime;
running = false;
} else {
throw new IllegalStateException("the stopwatch is not running");
}
}
public void reset() {
elapsedMillisec = 0;
}
public long read() {
if (running) {
elapsedMillisec = System.currentTimeMillis() - startTime;
}
return this.elapsedMillisec;
}
}
生成随机数组的方法
public static int[] getRandomIntArray(final int len, final int max, boolean allowNegative) {
final int[] intArray = new int[len];
final Random rand = new Random();
rand.setSeed(20100102);
if (!allowNegative) {
if (max <= 0) {
throw new IllegalArgumentException("max must be possitive if allowNegative false");
}
for (int i = 0; i < intArray.length; i++) {
intArray[i] = rand.nextInt(max);
}
} else {
int n;
int i = 0;
while (i < len) {
n = rand.nextInt();
if (n < max) {
intArray[i] = n;
i++;
}
}
}
return intArray;
}
你可以看到，我生成了一个带有20000个元素的int数组。因为我在getRandomIntArray方法中有一个固定的种子，所以每次调用它时都会有相同的数组。 SortingDemo类有main方法，如果我运行这个类，我得到输出：
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 101 ms.
---------------------------------------------
O(n^2) | SelectionSort | 667 ms.
---------------------------------------------
O(n^2) | BubbleSort | 1320 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 39 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 11 ms.
---------------------------------------------
看起来不错。现在有些让我感到困惑的事情。如果我在SortingDemo中更改了demoList.add（）序列，请说：
demoList.add(new InsertionSort());
demoList.add(new SelectionSort());
demoList.add(new BubbleSort());
// OptimizedMergeSort before Mergesort
demoList.add(new OptimizedMergeSort());
demoList.add(new MergeSort());
我得到了：
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 103 ms.
---------------------------------------------
O(n^2) | SelectionSort | 676 ms.
---------------------------------------------
O(n^2) | BubbleSort | 1313 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 41 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 14 ms.
---------------------------------------------
为什么输出与第一次运行不同？ OptimizedMergeSort花费的时间比正常的MergeSort ...
如果我取消注释SortingDemo中的for (int x=1; x<6; x++)行，（用相同的数组运行测试5次）我得到了：
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 101 ms.
---------------------------------------------
O(n^2) | SelectionSort | 668 ms.
---------------------------------------------
O(n^2) | BubbleSort | 1311 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 37 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 10 ms.
---------------------------------------------
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 94 ms.
---------------------------------------------
O(n^2) | SelectionSort | 665 ms.
---------------------------------------------
O(n^2) | BubbleSort | 1308 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 5 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 7 ms.
---------------------------------------------
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 116 ms.
---------------------------------------------
O(n^2) | SelectionSort | 318 ms.
---------------------------------------------
O(n^2) | BubbleSort | 969 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 5 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 10 ms.
---------------------------------------------
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 116 ms.
---------------------------------------------
O(n^2) | SelectionSort | 319 ms.
---------------------------------------------
O(n^2) | BubbleSort | 964 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 5 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 5 ms.
---------------------------------------------
Sorting 20000 elements
=============================================
O(n^2) | InsertionSort | 116 ms.
---------------------------------------------
O(n^2) | SelectionSort | 320 ms.
---------------------------------------------
O(n^2) | BubbleSort | 963 ms.
---------------------------------------------
O(?) | OptimizedMergeSort | 4 ms.
---------------------------------------------
O(nlog(n))| MergeSort | 6 ms.
---------------------------------------------
对于其他排序，结果看起来合理。但是对于mergeSort，为什么第一次运行比以后花费更长的时间？ 37ms：OptimizedMergeSort为4ms。
我认为即使Optimized / MergeSort的实现错误，输出也应该保持不变，为什么有时候同一个方法调用需要更长的时间，有时会缩短时间？
作为信息，所有这些* Sort类扩展了一个超级抽象类Sorting。它有一个抽象方法void sort(int[] data)
MergeSort有mergeSorting方法和merge（）方法。
OptimizedMergeSort扩展MergeSort，并覆盖mergeSorting()方法，（因为当数组大小＆lt; = 7时，它将执行insertSort）并重用merge()类中的MergeSort方法。
感谢您阅读这篇长篇文章和代码。如果你们能给我一些解释，我感激不尽。
所有测试都是在linux下的Eclipse中完成的。
答案 0 :(得分：3)
微型基准测试Java代码非常棘手。
Just-in-Time编译器很可能会在某些时候将Java字节码编译成本机代码。每次编译都需要时间，但生成的代码可能会运行得更快。
还有其他陷阱，但我认为上述情况最有可能发生在您的情况中。
以下SO答案非常好读：https://stackoverflow.com/a/513259/367273
答案 1 :(得分：1)
基本上，有两个可能的原因，都与环境而不是程序有关：其他东西占用了大量空间，或者其他东西占用了大量的CPU时间。
在第一种情况下，您有一些其他程序正在消耗物理内存，导致您的程序更频繁地进行分页和/或垃圾回收。
在第二个，其他一些程序（如果你正在运行Mac，我打赌Time Machine）间歇性地运行消耗CPU。
在任何情况下，您可以找到的方法是开始使用Java附带的工具。 jconsole和VirtualVM是很好的可能性。
通常，当您遇到性能问题时，需要执行三个关键步骤：度量，度量和MEASURE。
<强>更新
我同意JIT可以有所作为，但我得到的印象是这些是单独的运行;你每次都在调用一个新的JVM。这最大限度地减少了JIT的影响。
答案 2 :(得分：0)
为了减少JIT的影响，您可以丢弃每次测试的初始几次运行。同样，对于更准确的结果，平均超过100或1000次运行。
在开始测量之前，您还可以执行System.gc（）和Thread.yeild（）。 如果你只想测试几次迭代，那就更喜欢system.nanoTime（）而不要使用system.currentTimeMillis（它不够准确）。