El método getAndAccumulate() de una clase AtomicReferenceArray se usa para actualizar atómicamente el elemento en el índice i de AtomicReferenceArray con los resultados de aplicar la función de acumulación dada a los valores actuales y dados y devuelve el valor anterior. AccumulatorFunction no debe tener efectos secundarios, ya que se puede volver a aplicar cuando fallan los intentos de actualización debido a la contención entre subprocesos. La función se aplica con el valor actual en el índice i como primer argumento y la actualización dada como segundo argumento.
Sintaxis:
public final E getAndAccumulate(int i, E x,
BinaryOperator<E> accumulatorFunction)
Parámetros: Este método acepta:
- i que es un índice de AtomicReferenceArray para realizar la operación acepta,
- x que es el valor actualizado y
- accumulatorFunction que es una función sin efectos secundarios de dos argumentos.
Valor devuelto: este método devuelve el valor anterior .
Los siguientes programas ilustran el método getAndAccumulate():
Programa 1:
// Java program to demonstrate
// getAndAccumulate() method
import java.util.concurrent.atomic.*;
import java.util.function.BinaryOperator;
public class GFG {
public static void main(String args[])
{
// an array
Integer a[]
= { 123, 1232, 1433, 134, 13415, 1343 };
// AtomicReferenceArray with array
AtomicReferenceArray<Integer> array
= new AtomicReferenceArray<>(a);
// Print AtomicReferenceArray
System.out.println(
"The AtomicReferenceArray before update: "
+ array);
// Index and Value to apply getAndAccumulate
int index = 2;
int E = 3;
// Declaring the accumulatorFunction
// applying function
BinaryOperator add
= (u, v)
-> Integer.parseInt(
u.toString())
* Integer
.parseInt(
v.toString());
// apply getAndAccumulate()
int value
= array.getAndAccumulate(index, E, add);
// print AtomicReferenceArray
System.out.println(
"previous value of index 2:"
+ value);
System.out.println(
"The AtomicReferenceArray after update: "
+ array);
}
}
Programa 2:
// Java program to demonstrate
// getAndAccumulate() method
import java.util.concurrent.atomic.*;
import java.util.function.BinaryOperator;
public class GFG {
public static void main(String args[])
{
// an array
String a[] = { "GFG", "JS" };
// AtomicReferenceArray with array
AtomicReferenceArray<String> array
= new AtomicReferenceArray<>(a);
// Print AtomicReferenceArray
System.out.println(
"The AtomicReferenceArray before update : "
+ array);
// Index and Value to apply getAndAccumulate
int index = 1;
String E = " PYTHON";
// Declaring the accumulatorFunction
// applying function to add value as string
BinaryOperator add
= (u, v) -> u.toString() + " and " + v.toString();
// apply getAndAccumulate()
String value
= array.getAndAccumulate(index, E, add);
// print AtomicReferenceArray
System.out.println(
"previous value of index 1:"
+ value);
System.out.println(
"The AtomicReferenceArray after update: "
+ array);
}
}
Publicación traducida automáticamente
Artículo escrito por AmanSingh2210 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA