Función atomic.AddUint64() 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 AddUint64() 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 AddUint64(addr *uint64, delta uint64) (new uint64)

Aquí, addr indica dirección y delta indica una pequeña cantidad de bits mayor que cero. Además, si desea restar un valor constante positivo con signo c de x, puede hacerlo mediante AddUint64(&x, ^uint64(c-1)) . Y si desea disminuir x en particular, puede hacerlo mediante AddUint64(&x, ^uint64(0)) .
Nota: (*uint64) es el puntero a un valor uint64. Además, uint64 contiene el conjunto de todos los enteros de 64 bits sin signo de 0 a 18446744073709551615.
Valor devuelto: agrega addr y delta automáticamente y devuelve un nuevo valor.
Ejemplo 1:
 

// Golang Program to illustrate the usage
// of AddUint64 function
 
// Including main package
package main
 
// importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
)
 
// Main function
func main() {
 
    // Assigning variable
    // values to the uint64
    var (
        i uint64 = 453
        j uint64 = 167
        k uint64 = 18446744073709551615
        l uint64 = 0
        z int    = 15
    )
 
    // Assigning constant values to uint64
    const (
        x uint64 = 7
        y uint64 = 12
    )
 
    // Calling AddUint64 method
    // with its parameters
    a_1 := atomic.AddUint64(&i, -uint64(z))
    a_2 := atomic.AddUint64(&j, ^(y - 1))
    a_3 := atomic.AddUint64(&k, x-1)
    a_4 := atomic.AddUint64(&l, ^uint64(z-1))
 
    // Displays the output after adding
    // addr and delta automatically
    fmt.Println(a_1)
    fmt.Println(a_2)
    fmt.Println(a_3)
    fmt.Println(a_4)
}

Producción: 
 

438
155
5
18446744073709551601

Ejemplo 2:
 

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

Producción: 
 

325
650
975

En el ejemplo anterior, hemos definido una función agrega que devuelve el resultado de llamar al método AddUint64 . En la función principal, hemos definido un bucle «for» que incrementará el valor de ‘u’ en cada llamada. Aquí, el segundo parámetro del método AddUint64() 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 AddUint64() en la siguiente llamada hasta que el bucle se detenga.
Veamos cómo funciona el ejemplo anterior:
 

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

// Now, the above output is 1st parameter in next call to AddUint64() method
1st parameter = 325, 2nd parameter =  325  // returns (325 + 325 = 650)
1st parameter = 650, 2nd parameter = 325   // returns (650 + 325 = 975)