Método AtomicReferenceArray compareAndExchangeAcquire() en Java con ejemplos

El método compareAndExchangeAcquire() de una clase AtomicReferenceArray se usa para establecer atómicamente el valor del índice i de AtomicReferenceArray en newValue, si el valor actual en el índice i del objeto AtomicReferenceArray al que se hace referencia como valor testigo es igual al valor esperado. Este método devolverá el valor testigo, que será el mismo que el valor esperado. Este método intercambia el valor con efectos de ordenamiento de memoria compatibles con el ordenamiento memory_order_acquire.

Sintaxis:

public final boolean
       compareAndExchangeAcquire(
           int i, E expectedValue, E newValue)

Parámetros: Este método acepta:

  • i que es un índice de AtomicReferenceArray para realizar la operación,
  • valoresperado que es el valor esperado y
  • newValue que es el nuevo valor a establecer.

Valor devuelto: este método devuelve el valor testigo , que será el mismo que el valor esperado si tiene éxito.

Los siguientes programas ilustran el método compareAndExchangeAcquire():
Programa 1:

// Java program to demonstrate
// compareAndExchangeAcquire() method
  
import java.util.concurrent.atomic.*;
  
public class GFG {
    public static void main(String[] args)
    {
        // create an atomic reference object.
        AtomicReferenceArray<Integer> ref
            = new AtomicReferenceArray<Integer>(3);
  
        // set some value
        ref.set(0, 1234);
        ref.set(1, 4322);
  
        // apply compareAndExchangeAcquire()
        int oldV1
            = ref.compareAndExchangeAcquire(
                0, 1234, 8913);
        int oldV2
            = ref.compareAndExchangeAcquire(
                1, 4322, 6543);
  
        // print
        System.out.println(
            "Old value at index 0: "
            + oldV1);
        System.out.println(
            "Old value at index 1: "
            + oldV2);
    }
}
Producción:

Programa 2:

// Java program to demonstrate
// compareAndExchangeAcquire() method
  
import java.util.concurrent.atomic.*;
  
public class GFG {
    public static void main(String[] args)
    {
        // create an atomic reference object.
        AtomicReferenceArray<String> ref
            = new AtomicReferenceArray<String>(3);
  
        // set some value
        ref.set(0, "GFG");
        ref.set(1, "JS");
  
        // apply compareAndExchangeAcquire()
        String oldV1
            = ref.compareAndExchangeAcquire(
                0, "GFG",
                "GEEKS FOR GEEKS");
        String oldV2
            = ref.compareAndExchangeAcquire(
                1, "JS",
                "JAVA SCRIPT");
  
        // print
        System.out.println(
            "Old value at index 0: "
            + oldV1);
        System.out.println(
            "New value at index 0: "
            + ref.get(0));
        System.out.println(
            "Old value at index 1: "
            + oldV2);
        System.out.println(
            "New value at index 1: "
            + ref.get(1));
    }
}
Producción:

Referencias: https://docs.oracle.com/javase/10/docs/api/java/util/concurrent/atomic/AtomicReferenceArray.html#compareAndExchangeAcquire(int, E, E)

Publicación traducida automáticamente

Artículo escrito por AmanSingh2210 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *