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

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

Nota: (*uintptr) es el puntero a un valor de uintptr . Y uintptr es un tipo entero que es lo suficientemente grande y puede contener el patrón de bits de cualquier puntero.

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

Ejemplo 1:

// Golang Program to illustrate the usage of
// AddUintptr function
  
// Including main package
package main
  
// importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
)
  
// Main function
func main() {
  
    // Assigning variable
    // values to the uintptr
    var (
        w uintptr = 0
        x uintptr = 255
        y uintptr = 564688
        z uintptr = 656757686877
    )
  
    // Assigning constant 
    // values to uintptr
    const (
        m uintptr = 78
        n uintptr = 96
    )
  
    // Calling AddUintptr method
    // with its parameters
    p_1 := atomic.AddUintptr(&x, (m))
    p_2 := atomic.AddUintptr(&y, ^(n - 1))
    p_3 := atomic.AddUintptr(&z, (2))
    p_4 := atomic.AddUintptr(&w, (n - m))
  
    // Displays the output after adding
    // addr and delta automatically
    fmt.Println(p_1)
    fmt.Println(p_2)
    fmt.Println(p_3)
    fmt.Println(p_4)
}

Producción:

333
564592
656757686879
18

Ejemplo 2:

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

Producción:

32686776785
65373553570
98060330355
130747107140

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

Veamos cómo funciona el ejemplo anterior:

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

// Now, the above output is 1st parameter 
// in next call to AddUintptr() method
// It returns (32686776785 + 32686776785 = 65373553570)
1st parameter = 32686776785, 2nd parameter = 32686776785 

// returns (65373553570 + 32686776785 = 130747107140) and so on  
1st parameter = 65373553570, 2nd parameter = 32686776785