mayores a las de intercambio de comparación y

Question

como sugiere el título, estoy buscando una aplicación de comparación y de intercambio, pero con mayor que la comparación:

if(newValue > oldValue) { 
    oldValue = newValue; 
} 

donde oldValue es un estado global compartida y newValue es privado para cada hilo, sin hacer esto:

synchronized(locker) { 
    if(newValue > oldValue) { 
     oldValue = newValue; 
    }  
} 

porque quiero una solución no bloqueante. Del estudio de los códigos fuente de las demás operaciones no bloqueantes, yo he llegado con esto (suponiendo que los valores son números enteros):

AtomicInteger oldValue; // shared global variable 

... 

public boolean GreaterThanCAS(int newValue) { 

    while(true) { 
     int local = oldValue; 
     if(local == oldValue) { 
      if(newValue > local) { 
       if(oldValue.compareAndSet(local, newValue) { 
        return true; // swap successful 
       } // else keep looping 
      } else { 
       return false; // swap failed 
      } 
     } // else keep looping 
    } 
} 

cuando // else keep looping sucede, significa que otro hilo ha cambiado la oldValue en el ínterin y entonces necesito repetir y volver a intentarlo

¿Es correcta esta implementación (sin hilos)?

Answer 1

No veo ningún problema con su implementación, siempre que ningún hilo disminuya el valor de AtomicInteger. Si lo hacen, su código está abierto a condiciones de carrera.

Tenga en cuenta que el código puede simplificarse de la siguiente manera:

public boolean GreaterThanCAS(int newValue) { 
    while(true) { 
     int local = oldValue.get(); 
     if(newValue <= local) { 
      return false; // swap failed 
     } 
     if(oldValue.compareAndSet(local, newValue)) { 
      return true; // swap successful 
     } 
     // keep trying 
    } 
} 

Answer 2

Me gustaría volver a escribirlo a parecerse más a:

while(true) { 
    int local = oldValue.get(); 
    if(newValue > local){ 
     if(oldValue.compareAndSwap(local, newValue) { 
       return true; // swap successful 
     } // else keep looping 
    }else 
     return false; 
} 

La verificación de equivalencia antes de que el cheque más grande que es redundante.

De lo contrario, debería funcionar bien.

Answer 3

Desde Java 8 este puede simplificarse con el uso de updateAndGet:

public boolean greaterThanCAS(int newValue) { 
    return oldValue.updateAndGet(x -> x < newValue ? newValue : x) == newValue; 
} 

Tenga en cuenta que esto podría volver cierto también en el caso en que los valores antiguos y nuevos son iguales. Pruebe @Adam's answer si este no es el comportamiento deseado.

Answer 4

@Vadzim, habría comentado tu publicación, pero stackoverflow dice que no tengo suficientes puntos para publicar comentarios. Su respuesta es casi correcta, pero su función siempre será falsa porque getAndUpdate siempre devuelve el valor anterior, o 'x' en su caso. Creo que todo lo que tendría que hacer es reemplazar su última '==' con '<', por ejemplo:

// return true if the assignment was made, false otherwise 
public boolean greaterThanCAS(int newValue) { 
    return oldValue.getAndUpdate(x -> x < newValue ? newValue : x) < newValue; 
}