Método AtomicReferenceArrayacumularAndGet() en Java con ejemplos

El método AccumAndGet () de una clase AtomicReferenceArray se usa para actualizar de forma atómica el elemento en el índice i de AtomicReferenceArray con los resultados de aplicar la AccumulatorFunction dada a los valores actuales y dados y devuelve el valor actualizado. 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 accumulateAndGet(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 actualizado .

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

// Java program to demonstrate
// accumulateAndGet() 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\n: "
            + array);
  
        // Index and Value to apply accumulateAndGet
        int index = 2;
        int E = 343;
  
        // Declaring the accumulatorFunction
        // applying function to add value as string
        BinaryOperator add
            = (u, v)
            -> u.toString()
                   + v.toString();
  
        // apply accumulateAndGet()
        array.accumulateAndGet(index, E, add);
  
        // print AtomicReferenceArray
        System.out.println(
            "The AtomicReferenceArray "
            + "after update \n: "
            + array);
    }
}
Producción:

Programa 2:

// Java program to demonstrate
// accumulateAndGet() 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> arra
            = new AtomicReferenceArray<>(a);
  
        // Print AtomicReferenceArray
        System.out.println(
            "The AtomicReferenceArray"
            + " before update \n: "
            + array);
  
        // Index and Value to apply accumulateAndGet
        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 accumulateAndGet()
        array.accumulateAndGet(index, E, add);
  
        // print AtomicReferenceArray
        System.out.println(
            "The AtomicReferenceArray"
            + " after update \n: "
            + array);
    }
}
Producción:

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

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 *