Null/Objekt und Null/Null Vergleich Effizienz

Question

This question mich führen einige Tests zu tun:

public class Stack 
{ 
    public static void main(String[] args) 
    { 
     Object obj0 = null; 
     Object obj1 = new Object(); 
     long start; 
     long end; 
     double difference; 
     double differenceAvg = 0; 

     for (int j = 0; j < 100; j++) 
     { 
      start = System.nanoTime(); 

      for (int i = 0; i < 1000000000; i++) 
       if (obj0 == null); 

      end = System.nanoTime(); 
      difference = end - start; 
      differenceAvg +=difference; 
     } 

     System.out.println(differenceAvg/100); 
     differenceAvg = 0; 

     for (int j = 0; j < 100; j++) 
     { 
      start = System.nanoTime(); 

      for (int i = 0; i < 1000000000; i++) 
       if (null == obj0); 

      end = System.nanoTime(); 
      difference = end - start; 
      differenceAvg +=difference; 
     } 

     System.out.println(differenceAvg/100); 
     differenceAvg = 0; 

     for (int j = 0; j < 100; j++) 
     { 
      start = System.nanoTime(); 

      for (int i = 0; i < 1000000000; i++) 
       if (obj1 == null); 

      end = System.nanoTime(); 
      difference = end - start; 
      differenceAvg +=difference; 
     } 

     System.out.println(differenceAvg/100); 
     differenceAvg = 0; 

     for (int j = 0; j < 100; j++) 
     { 
      start = System.nanoTime(); 

      for (int i = 0; i < 1000000000; i++) 
       if (null == obj1); 

      end = System.nanoTime(); 
      difference = end - start; 
      differenceAvg +=difference; 
     } 

     System.out.println(differenceAvg/100);  
    } 
} 

Tangential zum other post, ist es interessant zu sehen, wie viel schneller ist der Vergleich, wenn die Object dass wir vergleichen, wird initialisiert. Die ersten beiden Zahlen in jedem Ausgang sind, wenn der Object war null und die letzten beiden Zahlen sind, wenn der Object initialisiert wurde. Ich führte 21 zusätzliche Ausführungen des Programms, in allen 30 Ausführungen war der Vergleich viel schneller, wenn die Object initialisiert wurde. Was ist denn hier los?

Answer 1

Wenn Sie die letzten beiden Schleifen an den Anfang verschieben, erhalten Sie die gleichen Ergebnisse, so dass Vergleiche irrelevant sind.

Es geht um JIT-Compiler-Warm-up. Während der ersten 2 Schleifen beginnt java mit der Interpretation von Bytecode. Nach einigen Iterationen bestimmt es, dass der Code-Pfad "heiß" ist, also kompiliert er ihn zum Maschinen-Code und entfernt die Schleifen, die keine Wirkung haben, so dass Sie im Grunde System.nanotime und double Arithmetik messen.

Ich bin nicht wirklich sicher, warum zwei Schleifen langsam sind. Ich denke, nachdem es zwei heiße Pfade gefunden hat, entscheidet es, die gesamte Methode zu optimieren.