AtomicInteger.incrementAndGet() frente a AtomicInteger.getAndIncrement()

Question 1

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

Estoy pensando en diferencias como cuál sería más idiomático, así como cuál pondría menos carga en las memorias caché de la CPU sincronizadas, o cualquier otra cosa realmente, cualquier cosa que ayude a decidir cuál usar de manera más racional que lanzar una moneda.

Question 2

Como no se ha dado ninguna respuesta a la pregunta real, aquí está mi opinión personal basada en las otras respuestas (gracias, votado a favor) y la convención de Java:

incrementAndGet()

es mejor, porque los nombres de los métodos deben comenzar con el verbo que describe la acción, y la acción prevista aquí es solo incrementar.

Comenzar con verbo es la convención común de Java, también descrita por documentos oficiales:

“Los métodos deben ser verbos, en caso mixto con la primera letra en minúscula, con la primera letra de cada palabra interna en mayúscula”.

Question 3

El código es esencialmente el mismo, así 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;
    }
}

Question 4

No, no hay diferencia (si no te importa el valor de retorno).

El código de esos métodos (en OpenJDK) difiere solo en que uno usa return next y los otros usos return current.

Ambos usan compareAndSet bajo el capó con exactamente el mismo algoritmo. Ambos necesitan saber tanto el valor antiguo como el nuevo.

Question 5

Solo quiero agregar a las respuestas existentes: podría haber una diferencia muy pequeña que no se nota.

Si miras esta implementación:

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

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

Nota: ambas funciones llaman exactamente a la misma función getAndAddIntexcepto +1 parte, lo que significa que en esta implementación getAndIncrement es más rápido.

Pero, aquí está implementación anterior:

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 que ambas funciones realizan exactamente lo mismo.

Question 6

Aquí estoy dando un ejemplo. Espero que te aclare la duda.

Supongamos que tengo una variable i como

Entero atómico i = nuevo Entero atómico ();

En este caso:

i.getAndIncrement() i++;

Y

i.incrementarYObtener() ++i;

Por favor, eche un vistazo a 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);  

    }

}

**producción

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

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

    }

}

**producción

0 1 ————-**

Comentario: 1) En la clase Test1, incrementAndGet() primero incrementará el valor i y luego imprimirá.

2) En la clase Test2, getAndIncrement() primero imprimirá el valor i y luego lo incrementará.

Eso es todo.

En este caso:

**producción

**producción

¿Ha sido útil esta solución?