tontos - que es el lenguaje java pdf

java corto, entero, largo rendimiento

Question

Leí que JVM almacena internamente corto, entero y largo como 4 bytes. Lo leí de un artículo del año 2000, así que no sé cuán cierto es ahora.

Para las JVM más nuevas, ¿hay algún aumento en el rendimiento al usar short over integer / long? ¿Y esa parte de la implementación ha cambiado desde 2000?

Gracias

Answer 1

Es un detalle de implementación, pero sigue siendo cierto que, por motivos de rendimiento, la mayoría de las JVM utilizará una palabra completa (o más) para cada variable, ya que las CPU acceden a la memoria en unidades de palabras. Si la JVM almacenó las variables en unidades y ubicaciones de palabras secundarias, en realidad sería más lenta.

Esto significa que una JVM de 32 bits usará 4 bytes para abreviar (e incluso booleanos), mientras que una JVM de 64 bits usará 8 bytes. Sin embargo, lo mismo no es cierto para los elementos de la matriz.

Answer 2

Los tipos enteros se almacenan en muchos bytes, dependiendo del tipo exacto:

• byte en 8 bits
• corto en 16 bits, firmado
• int en 32 bits, firmado
• largo en 64 bits, firmado

Vea la especificación aquí .

En cuanto a rendimiento, depende de lo que estés haciendo con ellos. Por ejemplo, si está asignando un valor literal a un byte o abreviado, se escalarán a int porque los valores literales se consideran como enteros de forma predeterminada.

byte b = 10;  // upscaled to int, because "10" is an int

Es por eso que no puedes hacer:

byte b = 10;
b = b + 1;  // Error, right member converted to int, cannot be reassigned to byte without a cast.

Entonces, si planeas usar bytes o cortos para realizar algunos bucles, no ganarás nada.

for (byte b=0; b<10; b++) 
{ ... } 

Por otro lado, si está utilizando matrices de bytes o cortos para almacenar algunos datos, obviamente se beneficiará de su tamaño reducido.

byte[] bytes = new byte[1000];
int[] ints = new int[1000];  // 4X the size

Entonces, mi respuesta es: depende :)

Answer 3

long  64 –9,223,372,036,854,775,808 to 9 ,223,372,036,854,775,807 
int   32 –2,147,483,648 to 2,147,483,647 
short 16 –32,768 to 32,767 
byte   8 –128 to 127 

Usa lo que necesites, creo que los pantalones cortos rara vez se usan debido al pequeño rango y está en formato big-endian.

Cualquier ganancia de rendimiento sería mínima, pero como dije, si su aplicación requiere un rango más que el de un corto, vaya con int. El tipo largo puede ser demasiado grande para ti; pero nuevamente todo depende de tu aplicación.

Solo debe utilizar short si le preocupa el espacio (memoria); de lo contrario, use int (en la mayoría de los casos). Si está creando matrices y lo prueba, declare las matrices de tipo int y short. Short usará 1/2 del espacio en comparación con el int. Pero si ejecuta las pruebas según la velocidad / el rendimiento, verá poca o ninguna diferencia (si está tratando con matrices) , además, lo único que ahorrará es espacio.

También siendo eso un comentarista mencionado largo porque un largo es 64 bits. No podrá almacenar el tamaño de un largo en 4 bytes (observe el rango de largo).

Answer 4

Estoy de acuerdo con user2391480, los cálculos con pantalones cortos parecen ser mucho más caros . Aquí hay un ejemplo, donde en mi máquina (Java7 64bit, Intel i7-3770, Windows 7) las operaciones con cortos son aproximadamente ~ 50 veces más lentas que los enteros y los largos.

public class ShortTest {

public static void main(String[] args){
    calculate();
    calculate();
}

public static void calculate(){
    int N = 100000000;

    long time1=System.currentTimeMillis();
    short s=0;
    for(int i = 0; i<N;i++) {
        s+=1;
        s-=1;
    }
    long time2=System.currentTimeMillis();
    System.out.println("Time elapsed for shorts: "+(time2-time1));


    long time3=System.currentTimeMillis();
    int in=0;
    for(int i = 0; i<N;i++) {
        in+=1;
        in-=1;
    }
    long time4=System.currentTimeMillis();
    System.out.println("Time elapsed for ints: "+(time4-time3));


    long time5=System.currentTimeMillis();
    long l=0;
    for(int i = 0; i<N;i++) {
        l+=1;
        l-=1;
    }
    long time6=System.currentTimeMillis();
    System.out.println("Time elapsed for longs: "+(time6-time5));


    System.out.println(s+in+l);
}

}

Salida:

Time elapsed for shorts: 113
Time elapsed for ints: 2
Time elapsed for longs: 2
0
Time elapsed for shorts: 119
Time elapsed for ints: 2
Time elapsed for longs: 2
0

Nota: especificar "1" para que sea corto (para evitar el lanzamiento cada vez, como sugiere el usuario Robotnik como fuente de retraso) no parece ayudar, por ejemplo

    short s=0;
    short one = (short)1;
    for(int i = 0; i<N;i++) {
      s+=one;
      s-=one;
    }

EDITAR : modificado según la solicitud del usuario Hot Licks en el comentario, para invocar el método calculate () más de una vez fuera del método principal.

Answer 5

Básicamente no hay diferencia. Uno tiene que "confundir" el JITC un poco para que no reconozca que las operaciones de incremento / decremento son auto canceladas y que los resultados no se usan. Haga eso y los tres casos salgan iguales. (En realidad, short parece ser un poco más rápido).

public class ShortTest {

    public static void main(String[] args){
        // Do the inner method 5 times to see how it changes as the JITC attempts to
        // do further optimizations.
        for (int i = 0; i < 5; i++) {
            calculate(i);
        }
    }

    public static void calculate(int passNum){

        System.out.println("Pass " + passNum);
        // Broke into two (nested) loop counters so the total number of iterations could
        // be large enough to be seen on the clock.  (Though this isn''t as important when
        // the JITC over-optimizations are prevented.)
        int M = 100000;
        int N = 100000;
        java.util.Random r = new java.util.Random();
        short x = (short) r.nextInt(1);
        short y1 = (short) (x + 1);
        int y2 = x + 1;
        long y3 = x + 1;

        long time1=System.currentTimeMillis();
        short s=x;
        for (int j = 0; j<M;j++) {
            for(int i = 0; i<N;i++) {
                s+=y1;
                s-=1;
                if (s > 100) {
                    System.out.println("Shouldn''t be here");
                }
            }
        }
        long time2=System.currentTimeMillis();
        System.out.println("Time elapsed for shorts: "+(time2-time1) + " (" + time1 + "," + time2 + ")");


        long time3=System.currentTimeMillis();
        int in=x;
        for (int j = 0; j<M;j++) {
            for(int i = 0; i<N;i++) {
                in+=y2;
                in-=1;
                if (in > 100) {
                    System.out.println("Shouldn''t be here");
                }
            }
        }
        long time4=System.currentTimeMillis();
        System.out.println("Time elapsed for ints: "+(time4-time3) + " (" + time3 + "," + time4 + ")");


        long time5=System.currentTimeMillis();
        long l=x;
        for (int j = 0; j<M;j++) {
            for(int i = 0; i<N;i++) {
                l+=y3;
                l-=1;
                if (l > 100) {
                    System.out.println("Shouldn''t be here");
                }
            }
        }
        long time6=System.currentTimeMillis();
        System.out.println("Time elapsed for longs: "+(time6-time5) + " (" + time5 + "," + time6 + ")");


        System.out.println(s+in+l);
    }
}

Resultados:

C:/JavaTools>java ShortTest
Pass 0
Time elapsed for shorts: 59119 (1422405830404,1422405889523)
Time elapsed for ints: 45810 (1422405889524,1422405935334)
Time elapsed for longs: 47840 (1422405935335,1422405983175)
0
Pass 1
Time elapsed for shorts: 58258 (1422405983176,1422406041434)
Time elapsed for ints: 45607 (1422406041435,1422406087042)
Time elapsed for longs: 46635 (1422406087043,1422406133678)
0
Pass 2
Time elapsed for shorts: 31822 (1422406133679,1422406165501)
Time elapsed for ints: 39663 (1422406165502,1422406205165)
Time elapsed for longs: 37232 (1422406205165,1422406242397)
0
Pass 3
Time elapsed for shorts: 30392 (1422406242398,1422406272790)
Time elapsed for ints: 37949 (1422406272791,1422406310740)
Time elapsed for longs: 37634 (1422406310741,1422406348375)
0
Pass 4
Time elapsed for shorts: 31303 (1422406348376,1422406379679)
Time elapsed for ints: 36583 (1422406379680,1422406416263)
Time elapsed for longs: 38730 (1422406416264,1422406454994)
0

C:/JavaTools>java -version
java version "1.7.0_65"
Java(TM) SE Runtime Environment (build 1.7.0_65-b19)
Java HotSpot(TM) 64-Bit Server VM (build 24.65-b04, mixed mode)

Answer 6

Los cálculos con un tipo corto son extremadamente caros.

Tome el siguiente ciclo inútil, por ejemplo:

short t=0;
//int t=0;
//long t=0;
for(many many times...)
{
  t+=1;
  t-=1;
}

Si es corto, demorará literalmente 1000 veces más que si fuera un int o un largo.

Comprobado en las versiones JVM 6/7 de 64 bits en Linux