Cuando el valor de retorno no es de interés, hay alguna (incluso irrelevante en la práctica) diferencia entre AtomicInteger.getAndIncrement() y AtomicInteger.incrementAndGet() métodos, cuando el valor de retorno es ignorado?

Estoy pensando en diferencias, como que sería más idiomáticas, así como que pondría menos carga en la CPU almacena en caché llegar sincronizado, o otra cosa, cualquier cosa para ayudar a decidir cuál utilizar más racionalmente que lanzar una moneda.

  • si el valor de retorno es de interés, es posible que en el caso de AtomicInteger.getAndIncrement() dos hilos obtendrá el mismo valor?
InformationsquelleAutor hyde | 2013-02-28

5 Comentarios

  1. 29

    El código es esencialmente el mismo, por lo que no importa:

    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }
    
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }
    • incrementAndGet()==getAndIncrement()+1
    • No estoy seguro de que obtenga su punto – si no almacenar el valor devuelto, var.incrementAndGet(); y var.getAndIncrement(); producen exactamente el mismo resultado…
    • sí. Estoy diciendo que en realidad uno de los métodos es suficiente, el otro es una especie de redundante.
    • Ah lo siento… Sí. También no estoy seguro de por qué incrementAndGet no simplemente llame addAndGet(1) en lugar de la mayoría de duplicar el código…
    • Doug Lea está obsesionada con cada ciclo de CPU:)
    • El seguimiento, que en esta pregunta.

  2. 25

    Ya que no hay respuesta a la pregunta se le ha dado, aquí es mi opinión personal basada en las otras respuestas (gracias, upvoted) y la convención de Java:

    incrementAndGet()

    es mejor, porque el método de nombres deben comenzar con el verbo que describe la acción y la intención de la acción aquí es el incremento de sólo.

    Comenzando con un verbo es el común de la convención de Java, también descrito por oficial docs:

    «Los métodos deben ser verbos, en caso mixto, con la primera letra en minúscula, con la primera letra de cada uno de los internos de la palabra en mayúscula.»

    • Sería bueno si se expone una simple increment() método, sólo en aras de la legibilidad.
  3. 8

    No, no hay ninguna diferencia (si no se tiene en cuenta el valor de retorno).

    El código de los métodos (en el OpenJDK) difiere sólo en que uno utiliza return next y de otros usos,return current.

    Tanto el uso de compareAndSet bajo el capó con el mismo algoritmo. Ambos necesitan saber ambos, el antiguo y el nuevo valor.

  4. 4

    Sólo quiero añadir a las respuestas: podría ser muy pequeñas y no diferencia notable.

    Si usted mira esta aplicación:

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    Nota – la función a llamar a exactamente la misma función getAndAddInt, excepto +1 parte, lo que significa que en esta implementación getAndIncrement es más rápido.

    Pero, aquí es edad de aplicación:

    public final int getAndIncrement() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return current;
        }
    }
    
    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

    La única diferencia es la variable de retorno, por lo tanto las funciones de realizar exactamente la misma.

  5. -1

    Aquí estoy dando un ejemplo. Espero que clara tu duda.

    Supongamos que tengo una variable i como

    AtomicInteger i = nuevo AtomicInteger();

    En este caso:

    yo.getAndIncrement() <==> i++;

    Y

    yo.incrementAndGet() <==> ++i;

    Por favor, eche un vistazo de los siguientes programas

    public class Test1
    {   
        public static void main(String[] args) 
        {               
            AtomicInteger i = new AtomicInteger();
            System.out.println(i.incrementAndGet());  
            System.out.println(i);  
    
        }
    
    }

    **salida de

    1
    1
    ======================================**

    public class Test2
    {   
        public static void main(String[] args) 
        {               
            AtomicInteger i = new AtomicInteger();
            System.out.println(i.getAndIncrement());  
            System.out.println(i); 
    
        }
    
    }

    **salida de

    0
    1
    ————-**

    Comentario:
    1) En la clase Test1, incrementAndGet() será el primer incremento de la i valor y, a continuación, imprimir.

    2) En la clase Test2, getAndIncrement() será la primera impresión la que me de valor y, a continuación, incremento.

    Eso es todo.

    • Gracias por tu respuesta. Sin embargo, en su respuesta, el resultado es en realidad utilizado (impreso). La pregunta es acerca de una situación en la que «Cuando el valor de retorno no es de interés»

Dejar respuesta

Please enter your comment!
Please enter your name here