Leistung: größer / kleiner als vs nicht gleich

Frage ich mich, ob es einen Unterschied in der Leistung zwischen

überprüfen, ob ein Wert größer /kleiner als der andere

for(int x = 0; x < y; x++); //for y > x

und

überprüfen, ob ein Wert nicht gleich einem anderen

for(int x = 0; x != y; x++); //for y > x

... und warum?

Außerdem: Was ist, wenn ich Vergleiche auf null, gibt es einen weiteren Unterschied?

Wäre es schön, wenn die Antworten auch überlegen, eine assebled Blick auf den code.

EDIT:
Wie die meisten von Ihnen darauf hingewiesen, der Unterschied in der Leistung ist natürlich unwesentlich, aber mich interessiert der Unterschied auf der cpu-Ebene. Die Bedienung ist komplexer?

Mir ist es eher eine Frage zum lernen /verstehen der Technik.

Entfernte ich die Java tag, die ich versehentlich Hinzugefügt, weil die Frage war, bedeutete in der Regel nicht nur auf Java-Basis, sorry.

Vielleicht relevant: en.wikibooks.org/wiki/Microprocessor_Design/ALU_Flags

InformationsquelleAutor das Keks | 2013-09-03

25

Sollten Sie noch tun, was ist klarer, sicherer und einfacher zu verstehen. Diese micro-tuning-Diskussionen sind in der Regel eine Verschwendung von Zeit, weil
- Sie machen selten einen messbaren Unterschied
- wenn Sie einen Unterschied machen, dies kann sich ändern, wenn Sie eine andere JVM oder Prozessor. d.h. ohne Warnung.
Hinweis: die Maschine erzeugt wird, kann auch der Wechsel mit Prozessor oder JVM, so sah dies nicht sehr hilfreich ist in den meisten Fällen, auch wenn Sie sehr vertraut mit Assembler-code.

Was ist viel, viel wichtiger ist die Wartbarkeit der software.
- +1 ich habe es immer geliebt Ihre Antworten auf die Frage bezüglich performance und Effizienz. Speziell, weil ich bin zu schlecht darin 🙂
- Oder Sie realisieren es ist nicht so einfach, wie einfach zu erraten, was könnte eine gute Idee sein. Es ist sehr schwer zu finden ein Beispiel, das ist besser für die Aufführungen Grund, auch wenn es mehr zu verschleiern.
- Vereinbart. Obscurity aus performance-Gründen sollte auch nicht berücksichtigt werden, es sei denn, Ihre Anwendung ausführen muss, um Sie so optimal wie möglich (wie unter Umgebungen mit begrenztem Speicher/computing-Fähigkeiten, oder irgendeine ultra-komplexe simulation, die braucht so viel Saft wie möglich). Andernfalls werden Sie verschwenden alle, dass der freie Raum, yo.
- Vereinbart ist, und Sie nachweisen können, dass die obskuren code tatsächlich schneller. 😉 Das ist oft fehlen. BTW Die JVM optimiert common/spezifische Muster von code. Dies bedeutet, dass wenn Sie ein ungewöhnliches Muster (so weit wie die JVM betroffen ist) dein code ist wahrscheinlich langsamer, nicht schneller, auch wenn in der Theorie es könnte sein, schneller wenn Sie einen anderen compiler.
- Ehrlich, ich bin genervt von Antworten wie diese. Mein Programm läuft auf einem bestimmten JVM mit bestimmten specs und ich haben eine einfache Schleife mit ein paar Anweisungen, die ausgeführt werden soll, so viele Male wie möglich in einer kurzen Zeitspanne. Auch das verschieben einer Methode aus einer if-Anweisung und speichern das Ergebnis in eine variable zu, dann setzen Sie die variable in der, wenn eine deutlich messbare Wirkung!
- Ich schlage vor, Sie versuchen, mit JMH. Auch, wenn Sie den Wert in einem Feld, kann es optimiert werden entfernt.
- setzen Sie in ein Feld erzeugt einen messbaren performance-Schub, das ist das Ding, es ist irgendwie in keinem Zusammenhang zu der ursprünglichen Frage. Etwas, das Sie nicht erwarten würden, um ihn zu beschleunigen überhaupt tatsächlich eine Wirkung erzielt, also ich bin mir ziemlich sicher, dass jede Kleinigkeit kann eine Auswirkung.
- Ich bin mir nicht sicher, warum dies ist die höchste gestimmt beantworten, da die OP eine Frage im Bezug auf die Leistung, nicht die best practices des software engineering.
InformationsquelleAutor Peter Lawrey

Die Leistung ist absolut vernachlässigbar. Hier finden Sie den code, um es zu beweisen:

public class OpporatorPerformance {
    static long y = 300000000L;

    public static void main(String[] args) {
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());
        System.out.println("Test One: " + testOne());
        System.out.println("Test Two: " + testTwo());

    }

    public static long testOne() {
        Date newDate = new Date();
        int z = 0;
        for(int x = 0; x < y; x++){ //for y > x
            z = x;
        }
        return new Date().getTime() - newDate.getTime();
    }

    public static long testTwo() {
        Date newDate = new Date();
        int z = 0;
        for(int x = 0; x != y; x++){ //for y > x
            z = x;
        }
        return new Date().getTime() - newDate.getTime();
    }

}

Die Ergebnisse:

Test One: 342
Test Two: 332
Test One: 340
Test Two: 340
Test One: 415
Test Two: 325
Test One: 393
Test Two: 329

+1 Auf meinem letzten run hab ich Test One: 113 Test Two: 113 auf meinem laptop.
Sie sollten die Verwendung von System.nanoTime() für das benchmarking, das gibt Ihnen mehr Präzision.
danke! Irgendwie habe ich nicht gelernt hatte, dass noch. Die Sache ich mag über Sie ist, dass ich jetzt nicht importieren müssen java.util.Date. Obwohl die javadoc sagt, dass "Diese Methode liefert Nanosekunden-Präzision, aber nicht unbedingt Nanosekunden-Auflösung (das heißt, wie Häufig ändert sich der Wert) - keine Garantien gemacht werden, außer, dass die Auflösung mindestens so gut wie die der currentTimeMillis()." So würde ich nicht unbedingt Vertrauen in die Genauigkeit der zusätzliche Präzision.
Ich würde nicht Vertrauen Date().getTime() - Sie erstellen ein neues Objekt, nur um die Zeit zu Messen, die möglicherweise tatsächlich verdecken die benchmark. Warum nicht nanoTime() oder zumindest currentTimeMillis() (das ist eine der am schnellsten fordert, btw)?

InformationsquelleAutor James Dunn

4

Gibt es selten einen Leistungseinbruch, aber der erste ist viel zuverlässiger als es behandelt sowohl von den außergewöhnlichen Fällen, in denen
1. y < 0 anfangen
2. x oder y stimmt mit in den block.
- Es ist erwähnenswert, dass mehr Arten unterstützen != als < (alle Iteratoren, zum Beispiel, im Gegensatz zu random-access-Iteratoren), so != ist in der Regel verwendet für die Konsistenz.
InformationsquelleAutor OldCurmudgeon
0

Anderen Menschen zu haben scheinen, beantwortet von einem gemessenen Perspektive, sondern aus der Maschine, die Sie interessiert in der Arithmetik-Logik-Einheit (ALU), die Griffe der mathy bits auf einem "normalen Rechner". Es scheint eine ziemlich gute Details in Wie funktioniert weniger als und größer als die Arbeit auf einer logischen Ebene in Binär? für komplette details.

Aus rein logischer Ebene, die kurze Antwort ist, dass es einfacher zu sagen, wenn etwas ist nicht etwas, als es zu sagen, wenn etwas ist relativ zu etwas, aber das hat wahrscheinlich optimiert in Ihrem standard-personal-computer oder server, und Sie sehen nur die tatsächlichen Gewinne wahrscheinlich in kleinen persönlichen builds wie on-board-Computer für Drohnen oder andere Mikro-Technologien.

InformationsquelleAutor aetherwalker
-2

Frage mich, ob verschachtelten für jeden test werden die gleichen Ergebnisse ?
```
for(int x = 0; x < y; x++)
{   
  for(int x2 = 0; x2 < y; x2++)  {}   
}

for(int x = 0; x != y; x++)
{
  for(int x2 = 0; x2 != y; x2++) {}    
}
```
- warum haben Sie diese erhalten eine upvote? Testen Sie es selbst und geben Sie uns eine Antwort, nicht eine andere Frage.
InformationsquelleAutor Macrofeet

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.