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

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

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

這可以說是用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。

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