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 CompareAndSwapUintptr() en el lenguaje Go se usa para realizar la operación de comparación e intercambio para un valor uintptr . Esta función se define en el paquete atómico. Aquí, debe importar el paquete «sync/atomic» para usar estas funciones.
Sintaxis:
func CompareAndSwapUintptr(addr *uintptr, old, new uintptr) (swapped bool)
Aquí, addr indica la dirección, old indica el valor de uintptr que es el anterior y new es el uintptr. El nuevo valor que se intercambiará a sí mismo desde el valor anterior se almacena en addr.
Nota: (*uintptr) es el puntero a un valor de uintptr. Y uintptr es un tipo de entero sin signo que es demasiado grande y contiene un patrón de bits de cualquier puntero.
Valor devuelto: Devuelve verdadero si se logra el intercambio; de lo contrario, devuelve falso.
Ejemplo 1:
// Program to illustrate the usage of
// CompareAndSwapUintptr function in Golang
// 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 (
i uintptr = 34764686
j uintptr = 41343432525245
k uintptr = 0
)
// Calling CompareAndSwapUintptr
// method with its parameters
Swap1 := atomic.CompareAndSwapUintptr(&i,
34764686, 647567565)
Swap2 := atomic.CompareAndSwapUintptr(&j,
41343432525245, 76)
Swap3 := atomic.CompareAndSwapUintptr(&k,
0, 15)
// Displays true if
// swapped else false
fmt.Println(Swap1)
fmt.Println(Swap2)
fmt.Println(Swap3)
// Prints addr
fmt.Println(i)
fmt.Println(j)
fmt.Println(k)
}
Producción:
true true true 647567565 76 15
Ejemplo 2:
// Program to illustrate the usage of
// CompareAndSwapUintptr function in Golang
// 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 (
x uintptr = 56466244
)
// Swapping operation
var oldvalue = atomic.SwapUintptr(&x, 2344444)
// Printing old value
// and swapped value
fmt.Println("Swapped_value:", x,
", old_value:", oldvalue)
// Calling CompareAndSwapUintptr
// method with its parameters
Swap := atomic.CompareAndSwapUintptr(&x,
56466244, 13232324)
// Displays true if
// swapped else false
fmt.Println(Swap)
fmt.Println(x)
}
Producción:
Swapped_value: 2344444, old_value: 56466244 false 2344444
Aquí, el valor intercambiado obtenido de la operación de intercambio debe ser el valor anterior del método CompareAndSwapUintptr() pero aquí el valor anterior tomado es el valor anterior de la operación de intercambio que no es correcto, por eso se devuelve falso.
Publicación traducida automáticamente
Artículo escrito por nidhi1352singh y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA