Warum sind interface-Methoden-Aufrufe langsamer als konkrete Aufrufe?

Gibt es viele performance-Mythen, und einige waren wahrscheinlich wahr vor einigen Jahren, und einige würden immer noch wahr sein, bei VMs, die keine JIT.

Die Android-Dokumentation (denken Sie daran, dass Android nicht über eine JVM, Sie haben Dalvik VM) verwendet, um zu sagen, dass das aufrufen einer Methode eines interfaces war langsamer als die Berufung auf Sie für eine Klasse, so waren Sie es, einen Beitrag zur Verbreitung des Mythos (es ist auch möglich, dass es langsamer war auf der Dalvik VM, bevor Sie drehte sich auf die JIT). Die Dokumentation wird jetzt sagen:

Leistung Mythen

Früheren Versionen von diesem Dokument aus verschiedenen irreführenden Behauptungen. Wir
Adresse, einige von Ihnen hier.

Auf Geräten ohne JIT, es ist wahr, dass aufrufen von Methoden über einen
variable mit einer genauen Art, anstatt ein interface ist etwas mehr
effizient ist. (So, zum Beispiel, war es billiger, aufrufen von Methoden für ein
HashMap map als eine Karte ansehen, obwohl in beiden Fällen die Karte war ein
HashMap.) Es war nicht der Fall, dass dies 2x langsamer; die tatsächliche
Unterschied war mehr wie 6% langsamer. Darüber hinaus wird der JIT macht der zwei
effektiv nicht zu unterscheiden.

Quelle: Designing for performance auf Android

Das gleiche gilt wohl auch für die JIT der JVM, es wäre sehr seltsam, sonst.

Dies ist variation auf Bozho Beispiel. Es läuft mehr und re-verwendet die gleichen Objekte, so dass die cache-Größe spielt keine Rolle, so viel. Ich benutze auch ein array, so gibt es keinen overhead aus dem iterator.

public static void main(String[] args) {
    Random random = new Random();
    int testLength = 200 * 1000 * 1000;
    Foo[] foos = new Foo[testLength];
    Bar[] bars = new Bar[testLength];
    Foo1Impl foo1 = new Foo1Impl();
    Foo2Impl foo2 = new Foo2Impl();
    Bar1Impl bar1 = new Bar1Impl();
    Bar2Impl bar2 = new Bar2Impl();
    for (int i = 0; i < testLength; i++) {
        boolean flip = random.nextBoolean();
        foos[i] = flip ? foo1 : foo2;
        bars[i] = flip ? bar1 : bar2;
    }
    long start;
    start = System.nanoTime();
    for (Foo foo : foos) {
        foo.foo();
    }
    System.out.printf("The average abstract method call was %.1f ns%n", (double) (System.nanoTime() - start) / testLength);
    start = System.nanoTime();
    for (Bar bar : bars) {
        bar.bar();
    }
    System.out.printf("The average interface method call was %.1f ns%n", (double) (System.nanoTime() - start) / testLength);
}

Drucke

The average abstract method call was 4.2 ns
The average interface method call was 4.1 ns

wenn Sie die Reihenfolge tauschen Sie die tests ausführen, erhalten Sie

The average interface method call was 4.2 ns
The average abstract method call was 4.1 ns

Da ist mehr Unterschied, wie Sie den test ausführen, als welche Sie wählen.

Bekam ich das gleiche Ergebnis mit Java 6 update 26 und OpenJDK 7.

BTW: Wenn Sie das hinzufügen einer Schleife, die nur dann aufrufen, das gleiche Objekt jedes mal, erhalten Sie

The direct method call was 2.2 ns

Habe ich versucht, einen test schreiben, würde Quantifizierung der verschiedenen Möglichkeiten, die Methoden, die möglicherweise aufgerufen werden. Meine Ergebnisse zeigen, dass es ist nicht, ob es eine Methode ist eine Schnittstelle, die Methode oder nicht, was zählt, sondern eher der Typ der Referenz, über die Sie aufgerufen wird. Aufruf einer interface-Methode durch eine class-Referenz ist viel schneller (relativ zur Anzahl der Anrufe) als Aufruf der gleichen Methode, die auf der gleichen Klasse über eine Referenz zur Benutzeroberfläche Referenz.

Die Ergebnisse für 1.000.000 Aufrufe sind...

interface-Methode über die interface-Referenz: (nanos, millis) 5172161.0, 5.0

interface-Methode über abstrakte Referenz: (nanos, millis) 1893732.0, 1.8

interface-Methode über toplevel abgeleitet, Referenz: (nanos, millis) 1841659.0, 1.8

Konkrete Methode über konkrete Klasse Referenz: (nanos, millis) 1822885.0, 1.8

Beachten Sie, dass die ersten zwei Zeilen sind die Ergebnisse fordert, um genau die gleiche Methode, aber mit anderen Referenzen.

Und hier ist der code...

package interfacetest;

/**
 *
 * @author rpbarbat
 */
public class InterfaceTest
{
    static public interface ITest
    {
        public int getFirstValue();
        public int getSecondValue();
    }

    static abstract public class ATest implements ITest
    {
        int first = 0;

        @Override
        public int getFirstValue()
        {
            return first++;
        }
    }

    static public class TestImpl extends ATest
    {
        int second = 0;

        @Override
        public int getSecondValue()
        {
            return second++;
        }
    }

    static public class Test
    {
        int value = 0;

        public int getConcreteValue()
        {
            return value++;
        }
    }

    static int loops = 1000000;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        //Get some various pointers to the test classes
        //To Interface
        ITest iTest = new TestImpl();

        //To abstract base
        ATest aTest = new TestImpl();

        //To impl
        TestImpl testImpl = new TestImpl();

        //To concrete
        Test test = new Test();

        System.out.println("Method call timings - " + loops + " loops");


        StopWatch stopWatch = new StopWatch();

        //Call interface method via interface reference
        stopWatch.start();

        for (int i = 0; i < loops; i++)
        {
            iTest.getFirstValue();
        }

        stopWatch.stop();

        System.out.println("interface method via interface reference: (nanos, millis)" + stopWatch.getElapsedNanos() + ", " + stopWatch.getElapsedMillis());


        //Call interface method via abstract reference
        stopWatch.start();

        for (int i = 0; i < loops; i++)
        {
            aTest.getFirstValue();
        }

        stopWatch.stop();

        System.out.println("interface method via abstract reference: (nanos, millis)" + stopWatch.getElapsedNanos() + ", " + stopWatch.getElapsedMillis());


        //Call derived interface via derived reference
        stopWatch.start();

        for (int i = 0; i < loops; i++)
        {
            testImpl.getSecondValue();
        }

        stopWatch.stop();

        System.out.println("interface via toplevel derived reference: (nanos, millis)" + stopWatch.getElapsedNanos() + ", " + stopWatch.getElapsedMillis());


        //Call concrete method in concrete class
        stopWatch.start();

        for (int i = 0; i < loops; i++)
        {
            test.getConcreteValue();
        }

        stopWatch.stop();

        System.out.println("Concrete method via concrete class reference: (nanos, millis)" + stopWatch.getElapsedNanos() + ", " + stopWatch.getElapsedMillis());
    }
}


package interfacetest;

/**
 *
 * @author rpbarbat
 */
public class StopWatch
{
    private long start;
    private long stop;

    public StopWatch()
    {
        start = 0;
        stop = 0;
    }

    public void start()
    {
        stop = 0;
        start = System.nanoTime();
    }

    public void stop()
    {
        stop = System.nanoTime();
    }

    public float getElapsedNanos()
    {
        return (stop - start);
    }

    public float getElapsedMillis()
    {
        return (stop - start) / 1000;
    }

    public float getElapsedSeconds()
    {
        return (stop - start) / 1000000000;
    }
}

Diese wurde mit dem Oracle JDK 1.6_24. Hoffe, dies hilft, diese Frage stellen zu Bett...

Grüße,

Rodney Barbati