Función atomic.AddInt64() en Golang con ejemplos

En el lenguaje Go, los paquetes atómicos proporcionan una memoria atómica de nivel inferior que es útil para implementar algoritmos de sincronización. La función AddInt64() en el lenguaje Go se usa para agregar automáticamente delta a *addr . Esta función se define en el paquete atómico. Aquí, debe importar el paquete «sync/atomic» para usar estas funciones.

Sintaxis:

func AddInt64(addr *int64, delta int64) (new int64)

Aquí, addr indica dirección y delta indica una pequeña cantidad de bits mayor que cero.

Nota: (*int64) es el puntero a un valor int64. Además, int64 contiene el conjunto de todos los enteros de 64 bits con signo desde -9223372036854775808 hasta 9223372036854775807.

Valor devuelto: agrega addr y delta automáticamente y devuelve un nuevo valor.

Ejemplo 1:

// Golang program to illustrate the usage of
// AddInt64 function
  
// Including main package
package main
  
// importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
)
  
// Main function
func main() {
  
    // Assigning values 
    // to the int64
    var (
        s int64 = 67656
        t int64 = 90
        u int64 = 922337203685477580
        v int64 = -9223372036854775807
    )
  
    // Assigning constant
    // values to int64
    const (
        w int64 = 5
        x int64 = 8
    )
  
    // Calling AddInt64 method 
    // with its parameters
    output_1 := atomic.AddInt64(&s, w)
    output_2 := atomic.AddInt64(&t, x-w)
    output_3 := atomic.AddInt64(&u, x-6)
    output_4 := atomic.AddInt64(&v, -x)
  
    // Displays the output after adding
    // addr and delta automatically
    fmt.Println(output_1)
    fmt.Println(output_2)
    fmt.Println(output_3)
    fmt.Println(output_4)
}

Producción:

67661
93
922337203685477582
9223372036854775801

Ejemplo 2:

// Golang Program to illustrate the usage of
// AddInt64 function
  
// Including main package
package main
  
// importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
)
  
// Defining addr of type int64
type addr int64
  
// function that adds addr and delta
func (s *addr) adds() int64 {
  
    // Calling AddInt64() function 
    // with its parameter
    return atomic.AddInt64((*int64)(s), 9)
}
  
// Main function
func main() {
  
    // Defining s
    var s addr
  
    // For loop to increment 
    // the value of s
    for i := 1; i < 10000; i *= 5 {
  
        // Displays the new value 
        // after adding delta and addr
        fmt.Println(s.adds())
    }
}

Producción:

9
18
27
36
45
54

En el ejemplo anterior, hemos definido una función agrega que devuelve el resultado de llamar al método AddInt64 . En la función principal, hemos definido un bucle «for» que incrementará el valor de ‘s’ en cada llamada. Aquí, el segundo parámetro del método AddInt64() es constante y solo el valor del primer parámetro es variable. Sin embargo, la salida de la llamada anterior será el valor del primer parámetro del método AddInt64() en la próxima llamada hasta que el bucle se detenga.

Veamos cómo funciona el ejemplo anterior:

1st parameter = 0, 2nd parameter = 9   // returns (0 + 9 = 9)

// Now, the above output is 1st parameter in next call to AddInt64() method
1st parameter = 9, 2nd parameter = 9   // returns (9 + 9 = 18)
1st parameter = 18, 2nd parameter = 9   // returns (18 + 9 = 27) and so on.