Función atomic.Store() 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 Store() en el lenguaje Go se usa para establecer el valor de Value en x (es decir, interfaz).
Y todas las llamadas al método Store para un valor establecido deben usar valores de un tipo concreto idéntico. Además, Store de un tipo contradictorio se llamará panic . Esta función se define en el paquete atómico. Aquí, debe importar el paquete «sync/atomic» para usar estas funciones.

Sintaxis:

func (v *Value) Store(x interface{})

Aquí, v es el valor de cualquier tipo y x es la interfaz que es el tipo de resultado de salida del método Store.

Nota: (*Valor) es el puntero a un tipo de Valor . Y el tipo de valor proporcionado en el paquete estándar de sincronización/atómico se utiliza para almacenar atómicamente y cargar valores de cualquier tipo.

Valor de retorno: Almacena el valor proporcionado y se puede cargar cuando se requiera.

Ejemplo 1:

// Program to illustrate the usage of
// Store function in Golang
  
// Including main package
package main
  
// importing fmt and sync/atomic
import (
    "fmt"
    "sync/atomic"
)
  
// Main function
func main() {
  
    // Defining a struct type L
    type L struct{ x, y, z int }
  
    // Defining a variable to assign
    // values to the struct type L
    var r1 = L{9, 10, 11}
  
    // Defining Value type to store
    // values of any type
    var V atomic.Value
  
    // Calling Store function
    V.Store(r1)
  
    // Printed if the value stated is stored
    fmt.Println("Any type of value is stored!")
}

Producción:

Any type of value is stored!

En el ejemplo anterior, hemos utilizado el tipo de valor para almacenar los valores de cualquier tipo. Y estos valores se almacenan en r1, que es la interfaz indicada.

Ejemplo 2:

// Program to illustrate the usage of
// Store function in Golang
  
// Including main package
package main
  
// importing fmt and sync/atomic
import (
    "sync/atomic"
)
  
// Main function
func main() {
  
    // Defining a struct type L
    type L struct{ x, y, z int }
  
    // Defining a variable to assign
    // values to the struct type L
    var r1 = L{9, 10, 11}
  
    // Defining Value type to store
    // values of any type
    var V atomic.Value
  
    // Calling Store function
    V.Store(r1)
  
    // Storing value of 
    // different concrete type
    V.Store("GeeksforGeeks")
}

Producción:

panic: sync/atomic: store of inconsistently typed value into Value

goroutine 1 [running]:
sync/atomic.(*Value).Store(0x40c018, 0x99a40, 0xb23e8, 0x40e010)
    /usr/local/go/src/sync/atomic/value.go:77 +0x160
main.main()
    /tmp/sandbox206117237/prog.go:31 +0xc0

Aquí, el valor almacenado arriba es de un tipo concreto diferente, por lo que se llama pánico.