AtomicInteger para generación de secuencia limitada

Question

¿Cómo podemos usar AtomicInteger para una generación de secuencia limitada? Digamos que el número de secuencia debe estar entre 1 y 60. Una vez que la secuencia llega a 60 debe comenzar nuevamente desde 1. Escribí este código aunque no estoy seguro ¿Si esto es seguro o no?

public int getNextValue() 
{ 
int v; 
do 
{ 
    v = val.get(); 
    if (v == 60) 
    { 
    val.set(1); 
    } 
} 
    while (!val.compareAndSet(v , v + 1)); 
    return v + 1; 
    } 

Answer 1

Usted podría hacer

return val.getAndIncrement() % 60; 

A menos que usted está preocupado con el número entero superior a max-valor (2147483647). Si esto es una preocupación, se puede echar un vistazo a la implementación getAndIncrement:

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

Todo lo que tiene que cambiar es la línea int next... a algo como:

int next = (current + 1) % 60; 

---

Vaya. Esto recorre 0-> 59. Necesitabas 1-> 60, así que agrega uno al valor de retorno para obtener el resultado deseado.

Answer 2

No, no es hilo-seguro - no debe llamar set dentro de un ciclo:

int value, next; 
do { 
    value = val.get(); 
    next = (value == 60) ? 1 : (value + 1); 
} while (!val.compareAndSet(value, next); 
return next; 

Answer 3

Si realiza el método synchronized entonces será multi-hilo, siempre que el val se accede en ninguna otra parte. El enfoque es sin embargo un poco engorroso, me gustaría volver a escribir de la siguiente manera:

public synchronized int getNextValue() { 
    val.compareAndSet(60, 0); // Set to 0 if current value is 60. 
    return val.incrementAndGet(); 
} 

Esto da 1 hasta el 60 de vuelta incluido. Si realmente necesita 1 hasta con 59, entonces reemplace 60 por 59.

Answer 4

¿Alguna razón en particular para usar AtomicInteger aquí en lugar de solo un método simple sincronizado?

¿Qué tal algo tan simple como la siguiente:

private int val=1; 

public synchronized int getNextValue() { 
int v=val; 
val = (val==60) ? 1 : (val+1); 
return v; 
} 

Answer 5

respuesta rápida, no seguro para subprocesos. La prueba y el conjunto deben ser atómicos, a menos que sincronices todo el método. Tenga en cuenta que val.get() y la prueba de v no son atómicas. Si el hilo se produce después de v = val.get() obtendrá dos llamadas con el mismo número de secuencia.

Además, si el compareAndSet falla, nunca cambia los valores, será un bucle infinito.

AtomicInteger tiene una llamada getAndIncrement() . Eso te dará un valor limpio para volver.

El laminado es un poco más complicado. Una solución es modificar el valor de retorno. Algo así:

int v = val.getAndIncrement(); 
return (v % 60) + 1; 

Dado que cada subproceso tiene una copia local de v, podemos hacer algunas operaciones matemáticas con seguridad y devolver el valor. Hay un punto de fricción si obtienes un desbordamiento. Dependiendo de la frecuencia con que genere un número de secuencia, esto puede o no ser un problema.

Answer 6

Puede hacer esto en una sola línea usando Java 8.

AtomicInteger counter = new AtomicInteger(); 

public int getNextValue() { 
    return counter.updateAndGet(n -> (n >= 60) ? 1 : n + 1); 
}