オートボクシングの実験

Question

それは、オートボクシングについての実験です。主なアイデアは、別途StackとStack<Integer>で、pop()とpush()のマウントを実行することです。以下のコアクラス：

public class FixedCapcityStack<Item> { 
    private final int cap; 
    private Item[] arr; 
    private int N; 
    public FixedCapcityStack(int cap){ 
     this.cap = cap; 
     arr = (Item[]) new Object[cap]; 
    } 

    public void push(Item i){ 
     arr[N++] = i; 
    } 

    public Item pop(){// 不考虑其他其他情况,方便测试 
     return arr[--N]; 
    } 

    public boolean isEmpty() { 
     return N==0; 
    } 

    public boolean isFull() { 
     return N == cap; 
    } 
} 

public class FixedCapcityStackOfInts { 
    private final int cap; 
    private int[] arr; 
    private int N; 
    public FixedCapcityStackOfInts(int cap){ 
     this.cap = cap; 
     arr = new int[cap]; 
    } 

    public void push(int i){ 
     arr[N++] = i; 
    } 

    public int pop(){// 不考虑其他其他情况,方便测试 
     return arr[--N]; 
    } 

    public boolean isEmpty() { 
     return N==0; 
    } 

    public boolean isFull() { 
     return N == cap; 
    } 
} 

そして私は、テストに以下のコードを使用します。

public static void main(String args[]) { 
    Random random = new Random(); 
    int SIZE = 10; 
    FixedCapcityStackOfInts intStack = new FixedCapcityStackOfInts(SIZE); 
    //FixedCapcityStack<Integer> intStack = new FixedCapcityStack(SIZE); 

    int N = 200; 
    while (true) { 
     Stopwatch stopwatch = new Stopwatch(); 
     for (int j = 0; j < N; j++) { 
      for (int i = 0; i < SIZE; i++) { 
       intStack.push(random.nextInt()); 
      } 

      for (int i = 0; i < SIZE; i++) { 
       int k = intStack.pop(); 
      } 
     } 
     System.out.printf("N: %d, elapseTime: %f \n", N, stopwatch.elapsedTime()); 
     N*=2; 
    } 
} 

なしジェネリックとスタックの結果は

N: 100, elapseTime: 0.033000s 
N: 200, elapseTime: 0.026000s 
N: 400, elapseTime: 0.025000s 
N: 800, elapseTime: 0.047000s 
N: 1600, elapseTime: 0.124000s 
N: 3200, elapseTime: 0.238000s 
N: 6400, elapseTime: 0.490000s 
N: 12800, elapseTime: 0.731000s 
N: 25600, elapseTime: 1.437000s 
N: 51200, elapseTime: 2.951000s 
N: 102400, elapseTime: 5.891000s 
N: 204800, elapseTime: 11.810000s 
N: 409600, elapseTime: 23.699000s 
N: 819200, elapseTime: 46.441000s 

Stack<Integer>の結果は次のとおりです。

N: 100, elapseTime: 0.034000s 
N: 200, elapseTime: 0.018000s 
N: 400, elapseTime: 0.049000s 
N: 800, elapseTime: 0.053000s 
N: 1600, elapseTime: 0.150000s 
N: 3200, elapseTime: 0.251000s 
N: 6400, elapseTime: 0.536000s 
N: 12800, elapseTime: 0.885000s 
N: 25600, elapseTime: 1.570000s 
N: 51200, elapseTime: 3.181000s 
N: 102400, elapseTime: 6.321000s 
N: 204800, elapseTime: 12.923000s 
N: 409600, elapseTime: 25.643000s 
N: 819200, elapseTime: 51.373000s 

パフォーマンスは悪くありません。あなたがテストに次のコードを使用するとき は、しかし：

long start = System.currentTimeMillis(); 
Long sum = 0L; 
for (long i = 0; i < Integer.MAX_VALUE; i++) { 
    sum += i; 
} 
long end = System.currentTimeMillis(); 
System.out.println("Long sum took: " + (end - start) + " milliseconds"); 

start = System.currentTimeMillis(); 
long sum2 = 0L; 
for (long i = 0; i <Integer.MAX_VALUE; i++) { 
    sum2 += i; 
} 
end = System.currentTimeMillis(); 
System.out.println("long sum took: " + (end - start) + " milliseconds"); 

結果は次のとおりです。

Long sum took: 8043 milliseconds 
long sum took: 793 milliseconds 

ああ、神様、私！なぜ2つの結果がお互いに異なるのですか？もちろん、2つの結果からオートボクシングに関する結論も異なっています。それは私をたくさん混乱させます。最初の例で

Answer 1

は、スタックによって引き起こされるオーバーヘッドの多くは、自分自身をオブジェクトがあります。ボックス化されたプリミティブはクラスを遅くしますが、考慮すべき他のボトルネックがあります。

2番目の例では非常に少ないオーバーヘッドがはるかに顕著な原始的な非ボックス化対箱入りの性能差を作り、そこにあります。