如何解決在Java中，相同代碼塊的運行時間不同。這是為什么？？

基準測試錯誤。錯誤的非詳盡清單：

：單次測量幾乎總是錯誤的； ：我們可能開始使用僅適用于該方法中第一個循環的執行數據來編譯該方法； ：如果循環編譯，我們實際上可以預測結果； ：如果循環編譯，我們可以將循環丟掉

這可以說是用jmh正確地做到的：

@OutputTimeUnit(TimeUnit.NANOSECONDS)@BenchmarkMode(Mode.AverageTime)@Warmup(iterations = 3, time = 1)@Measurement(iterations = 3, time = 1)@Fork(10)@State(Scope.Thread)public class Longs { public static final int COUNT = 10; private Long[] refLongs; private long[] primLongs; /* * Implementation notes: * - copying the array from the field keeps the constant * optimizations away, but we implicitly counting the * costs of arraycopy() in; * - two additional baseline experiments quantify the * scale of arraycopy effects (note you can’t directly * subtract the baseline scores from the tests, because * the code is mixed together; * - the resulting arrays are always fed back into JMH * to prevent dead-code elimination */ @Setup public void setup() {primLongs = new long[COUNT];for (int i = 0; i < COUNT; i++) { primLongs[i] = 12l;}refLongs = new Long[COUNT];for (int i = 0; i < COUNT; i++) { refLongs[i] = 12l;} } @GenerateMicroBenchmark public long[] prim_baseline() {long[] d = new long[COUNT];System.arraycopy(primLongs, 0, d, 0, COUNT);return d; } @GenerateMicroBenchmark public long[] prim_sort() {long[] d = new long[COUNT];System.arraycopy(primLongs, 0, d, 0, COUNT);Arrays.sort(d);return d; } @GenerateMicroBenchmark public Long[] ref_baseline() {Long[] d = new Long[COUNT];System.arraycopy(refLongs, 0, d, 0, COUNT);return d; } @GenerateMicroBenchmark public Long[] ref_sort() {Long[] d = new Long[COUNT];System.arraycopy(refLongs, 0, d, 0, COUNT);Arrays.sort(d);return d; }}

…產生：

Benchmark Mode Samples Mean Mean error Unitso.s.Longs.prim_baseline avgt30 19.6040.327 ns/opo.s.Longs.prim_sort avgt30 51.2171.873 ns/opo.s.Longs.ref_baseline avgt30 16.9350.087 ns/opo.s.Longs.ref_sort avgt30 25.1990.430 ns/op

在這一點上，您可能會開始懷疑為什么排序Long[]和排序long[]會花費不同的時間。答案在于Array.sort()重載：OpenJDK通過不同的算法（使用Timsort的引用，使用雙數據點快速排序的基元）對基元數組和引用數組進行排序。這是使用選擇另一個算法的亮點-Djava.util.Arrays.useLegacyMergeSort=true，這又落到了合并排序的參考上：

Benchmark Mode Samples Mean Mean error Unitso.s.Longs.prim_baseline avgt30 19.6750.291 ns/opo.s.Longs.prim_sort avgt30 50.8821.550 ns/opo.s.Longs.ref_baseline avgt30 16.7420.089 ns/opo.s.Longs.ref_sort avgt30 64.2071.047 ns/op

希望這有助于解釋差異。

上面的解釋幾乎沒有涉及排序的性能。當使用不同的源數據（包括可用的預排序子序列，它們的模式和游程長度，數據本身的大小）呈現時，性能會有很大不同。

解決方法

我有下面的代碼。我只想檢查代碼塊的運行時間。錯誤地，我再次復制并粘貼了相同的代碼，并得到了有趣的結果。盡管代碼塊相同，但運行時間不同。而且codeblock 1 比其他人花費更多的時間。如果我切換代碼塊，(say i move the code blocks 4 to thetop)則代碼塊4將比其他代碼花費更多時間。

我在代碼塊中使用了兩種不同類型的數組來檢查它是否依賴于此。結果是一樣的。如果代碼塊具有相同類型的數組，則最上面的代碼塊將花費更多時間。參見下面的代碼和給出的輸出。

public class ABBYtest {public static void main(String[] args) { long startTime; long endTime; //code block 1 startTime = System.nanoTime(); Long a[] = new Long[10]; for (int i = 0; i < a.length; i++) {a[i] = 12l; } Arrays.sort(a); endTime = System.nanoTime(); System.out.println('code block (has Long array) 1 = ' + (endTime - startTime)); //code block 6 startTime = System.nanoTime(); Long aa[] = new Long[10]; for (int i = 0; i < aa.length; i++) {aa[i] = 12l; } Arrays.sort(aa); endTime = System.nanoTime(); System.out.println('code block (has Long array) 6 = ' + (endTime - startTime)); //code block 7 startTime = System.nanoTime(); Long aaa[] = new Long[10]; for (int i = 0; i < aaa.length; i++) {aaa[i] = 12l; } Arrays.sort(aaa); endTime = System.nanoTime(); System.out.println('code block (has Long array) 7 = ' + (endTime - startTime)); //code block 2 startTime = System.nanoTime(); long c[] = new long[10]; for (int i = 0; i < c.length; i++) {c[i] = 12l; } Arrays.sort(c); endTime = System.nanoTime(); System.out.println('code block (has long array) 2 = ' + (endTime - startTime)); //code block 3 startTime = System.nanoTime(); long d[] = new long[10]; for (int i = 0; i < d.length; i++) {d[i] = 12l; } Arrays.sort(d); endTime = System.nanoTime(); System.out.println('code block (has long array) 3 = ' + (endTime - startTime)); //code block 4 startTime = System.nanoTime(); long b[] = new long[10]; for (int i = 0; i < b.length; i++) {b[i] = 12l; } Arrays.sort(b); endTime = System.nanoTime(); System.out.println('code block (has long array) 4 = ' + (endTime - startTime)); //code block 5 startTime = System.nanoTime(); Long e[] = new Long[10]; for (int i = 0; i < e.length; i++) {e[i] = 12l; } Arrays.sort(e); endTime = System.nanoTime(); System.out.println('code block (has Long array) 5 = ' + (endTime - startTime));}}

運行時間：

code block (has Long array) 1 = 802565

code block (has Long array) 6 = 6158

code block (has Long array) 7 = 4619

code block (has long array) 2 = 171906

code block (has long array) 3 = 4105

code block (has long array) 4 = 3079

code block (has Long array) 5 = 8210

如我們所見，包含的第一個代碼塊Long array將比包含的其他代碼花費更多的時間Long arrays。包含的第一個代碼塊也是如此longarray。

任何人都可以解釋這種行為。還是我在這里做錯了？