Función atomic.SwapPointer() 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 SwapPointer() en el lenguaje Go se usa para almacenar atómicamente un nuevo valor en *addr y devuelve el valor anterior de *addr . Esta función se define en el paquete atómico. Aquí, debe importar el paquete «sync/atomic» para usar estas funciones.

Sintaxis:

func SwapPointer(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)

Aquí, addr indica dirección. Y new es el nuevo valor de unsafe.Pointer y old es el antiguo valor de unsafe.Pointer .

Nota: (*unsafe.Pointer) es el puntero a un valor de unsafe.Pointer . Y unsafe.Pointer type es útil para permitir transiciones entre tipos arbitrarios y el tipo uintptr integrado . Además, unsafe es un paquete que es útil en la seguridad de tipo de los programas Go.

Valor de retorno: Almacena el nuevo valor de unsafe.Pointer en *addr y devuelve el valor anterior de *addr .

Ejemplo 1:

// Program to illustrate the usage of
// SwapPointer function in Golang
  
// Including main package
package main
  
// Importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
    "unsafe"
)
  
// Defining a struct type L
type L struct{ x, y, z int }
  
// Declaring pointer to L struct type
var PL *L
  
// Main function
func main() {
  
    // Defining *addr unsafe.Pointer
    var unsafepL = (*unsafe.Pointer)(unsafe.Pointer(&PL))
  
    // Defining values 
    // of unsafe.Pointer
    var px, py L
  
    // Storing value to the pointer
    atomic.StorePointer(
        unsafepL, unsafe.Pointer(&px))
  
    // Calling SwapPointer() method
    px1 := atomic.SwapPointer(unsafepL,
                  unsafe.Pointer(&py))
  
    // Returns true if swapped
    fmt.Println((*L)(px1) == &px)
  
    // Prints output
    fmt.Println(px1)
}

Producción:

true
0xc0000c2000  // Can be different at different run times

Aquí, el método StorePointer agrega valor a *addr, luego el método SwapPointer almacena atómicamente el nuevo valor en *addr y devuelve el valor anterior. Y, aquí se logra el intercambio, por lo tanto, se devuelve verdadero y el valor de inseguro . El puntero devuelto aquí puede ser diferente en diferentes tiempos de ejecución.

Ejemplo 2:

// Program to illustrate the usage of
// SwapPointer function in Golang
  
// Including main package
package main
  
// Importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
    "unsafe"
)
  
// Defining a struct type L
type L struct{ x, y, z int }
  
// Declaring pointer
// to L struct type
var PL *L
  
// Main function
func main() {
  
    // Defining *addr unsafe.Pointer
    var unsafepL = (*unsafe.Pointer)(unsafe.Pointer(&PL))
  
    // Defining values of unsafe.Pointer
    var px, py L
  
    // Calling SwapPointer() method
    px1 := atomic.SwapPointer(unsafepL,
                  unsafe.Pointer(&py))
  
    // Returns true if swapped
    fmt.Println((*L)(px1) == &px)
  
    // Prints output
    fmt.Println(&px1)
}

Producción:

false
0xc00000e028  // Can be different at different run times

Aquí, se devuelve falso ya que aquí el puntero inseguro no se almacenó antes, por lo que el método SwapPointer() no pudo intercambiar el valor indicado. Además, el valor de dirección devuelto aquí es la dirección de px1 y el valor de px1 será nulo ya que no se realiza el intercambio.