Java.util.concurrent.atomic.AtomicIntegerArray.compareAndSet () es un método incorporado en Java que establece atómicamente el elemento en una posición en el valor actualizado dado si el valor actual es igual al valor esperado. Este método toma el valor del índice, el valor esperado y el valor de actualización como parámetros y devuelve un valor booleano que indica si el valor se ha actualizado.
Sintaxis:
booleano final público compareAndSet(int i, int expect, int update)
Parámetros: La función acepta tres parámetros:
- i : El índice donde se va a realizar la operación.
- expect : El valor esperado para verificar si es igual al valor actual.
- actualizar : el valor que se actualizará.
Valor devuelto: la función devuelve un valor booleano que indica si el valor se ha actualizado. Devuelve verdadero si tiene éxito, de lo contrario devuelve falso indicando que el valor actual no era igual al valor esperado.
Los siguientes programas ilustran el método anterior:
Programa 1:
// Java program that demonstrates
// the compareAndSet() function
import java.util.concurrent.atomic.AtomicIntegerArray;
public class GFG {
public static void main(String args[])
{
// Initializing an array
int a[] = { 1, 2, 3, 4, 5 };
// Initializing an AtomicIntegerArray with array a
AtomicIntegerArray arr = new AtomicIntegerArray(a);
// Displaying the AtomicIntegerArray
System.out.println("The array : " + arr);
// Index where operation is performed
int idx = 3;
// Value to expect at idx
int expect = 4;
// Value to update if current value
// is equal to expected value
int update = 40;
// Updating the value at idx
// applying compareAndSet
arr.compareAndSet(idx, expect, update);
// Displaying the AtomicIntegerArray
System.out.println("The array after update : "
+ arr);
}
}
The array : [1, 2, 3, 4, 5] The array after update : [1, 2, 3, 40, 5]
Programa 2:
// Java program that demonstrates
// the compareAndSet() function
import java.util.concurrent.atomic.AtomicIntegerArray;
public class GFG {
public static void main(String args[])
{
// Initializing an array
int a[] = { 1, 2, 3, 4, 5 };
// Initializing an AtomicIntegerArray with array a
AtomicIntegerArray arr = new AtomicIntegerArray(a);
// Displaying the AtomicIntegerArray
System.out.println("The array : " + arr);
// Index where operation is performed
int idx = 3;
// Value to expect at idx
int expect = 40;
// Value to update if current value
// is equal to expected value
int update = 4;
// Updating the value at
// idx applying compareAndSet
arr.compareAndSet(idx, expect, update);
// Displaying the AtomicIntegerArray
System.out.println("The array after update : "
+ arr);
}
}
The array : [1, 2, 3, 4, 5] The array after update : [1, 2, 3, 4, 5]
Referencia: Java.util.concurrent.atomic.AtomicIntegerArray.compareAndSet () es un método incorporado en Java que establece atómicamente el elemento en una posición en el valor actualizado dado si el valor actual es igual al valor esperado. Este método toma el valor del índice, el valor esperado y el valor de actualización como parámetros y devuelve un valor booleano que indica si el valor se ha actualizado.
Sintaxis:
public final boolean compareAndSet(int i, Integer expect, Integer update)
Parámetros: La función acepta tres parámetros:
Valor devuelto: la función devuelve un valor booleano que indica si el valor se ha actualizado. Devuelve verdadero si tiene éxito, de lo contrario devuelve falso indicando que el valor actual no era igual al valor esperado.
Los siguientes programas ilustran el método anterior:
Programa 1:
// Java program that demonstrates
// the compareAndSet() function
import java.util.concurrent.atomic.AtomicIntegerArray;
public class GFG {
public static void main(String args[])
{
// Initializing an array
Integer a[] = { 1, 2, 3, 4, 5 };
// Initializing an AtomicIntegerArray with array a
AtomicIntegerArray arr = new AtomicIntegerArray(a);
// Displaying the AtomicIntegerArray
System.out.println("The array : " + arr);
// Index where operation is performed
int idx = 3;
// Value to expect at idx
Integer expect = 4;
// Value to update if current value
// is equal to expected value
Integer update = 40;
// Updating the value at idx
// applying compareAndSet
arr.compareAndSet(idx, expect, update);
// Displaying the AtomicIntegerArray
System.out.println("The array after update : "
+ arr);
}
}
The array : [1, 2, 3, 4, 5] The array after update : [1, 2, 3, 40, 5]
Programa 2:
// Java program that demonstrates
// the compareAndSet() function
import java.util.concurrent.atomic.AtomicIntegerArray;
public class GFG {
public static void main(String args[])
{
// Initializing an array
Integer a[] = { 1, 2, 3, 4, 5 };
// Initializing an AtomicIntegerArray with array a
AtomicIntegerArray arr = new AtomicIntegerArray(a);
// Displaying the AtomicIntegerArray
System.out.println("The array : " + arr);
// Index where operation is performed
int idx = 3;
// Value to expect at idx
Integer expect = 40;
// Value to update if current value
// is equal to expected value
Integer update = 4;
// Updating the value at
// idx applying compareAndSet
arr.compareAndSet(idx, expect, update);
// Displaying the AtomicIntegerArray
System.out.println("The array after update : "
+ arr);
}
}
The array : [1, 2, 3, 4, 5] The array after update : [1, 2, 3, 4, 5]