performance - segundo - signos<>=

Rendimiento: mayor/menor que vs no igual a

Question

Me pregunto si hay una diferencia en el rendimiento entre

Comprobar si un valor es mayor / menor que otro

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

y

comprobando si un valor no es igual a otro

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

¿y por qué?

Además: ¿Qué pasa si me comparo con cero, hay una diferencia adicional?

Sería bueno si las respuestas también consideraran una vista descompuesta en el código.

EDITAR: Como la mayoría de ustedes señaló la diferencia en el rendimiento, por supuesto, es insignificante, pero estoy interesado en la diferencia en el nivel de la CPU. ¿Qué operación es más compleja?

Para mí es más una pregunta para aprender / entender la técnica.

Quité la etiqueta de Java , la cual agregué accidentalmente porque la pregunta no era solo basada en Java, lo siento.

Answer 1

Aún debe hacer lo que sea más claro, más seguro y más fácil de entender. Estas discusiones de micro-tuning son generalmente una pérdida de tiempo porque

• rara vez hacen una diferencia medible
• cuando marcan la diferencia, esto puede cambiar si utiliza una JVM o procesador diferente. Es decir, sin previo aviso.

Nota: la máquina generada también puede cambiar con el procesador o JVM, por lo que mirar esto no es muy útil en la mayoría de los casos, incluso si está muy familiarizado con el código de ensamblaje.

Lo que es mucho más importante es la capacidad de mantenimiento del software.

Answer 2

El rendimiento es absolutamente despreciable . Aquí hay un código para probarlo:

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();
}
}

Los resultados:

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

Answer 3

Me pregunto si está anidado para cada prueba, los mismos resultados?

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++) {}
}

Answer 4

Rara vez hay un impacto en el rendimiento, pero el primero es mucho más confiable ya que manejará ambos casos extraordinarios en los que

1. y <0 para comenzar
2. X o y se meten dentro del bloque.