El Golang mutex

Un mutex se refiere a un mecanismo de bloqueo que garantiza que solo una función o goroutine accedan a una sección específica de un programa a la vez. Es una parte crítica de la gestión de la concurrencia que evita las condiciones de la carrera.

Una condición de carrera se refiere a una instancia en la que más de un hilo intenta acceder a los datos compartidos.

En este artículo, discutiremos los conceptos básicos de implementar un mutex utilizando el paquete de sincronización GO.

Paquete de sincronización de Golang

El paquete de sincronización en GO nos proporciona herramientas y métodos para implementar tareas de sincronización, como grupos de espera y exclusiones mutuas.

Para este artículo, solo estamos interesados ​​en los bloqueos de exclusiones mutuas o mutex para abreviar. El paquete Sync nos proporciona dos métodos para implementar mutex en los programas GO:

1. Cerrar con llave()
2. Desbloquear()

Si coloca algún código entre los métodos de bloqueo y desbloqueo, los programas Go solo permitirán que un solo hilo o una goroutine acceda a ese código.

Tomemos un programa simple con condiciones de carrera:

paquete principal
importar (
"FMT"
"Sincronización"
)
var x = 1
FUNC ADD (WG *SYNC.WaitGroup)
X++
WG.Hecho()

func Main ()
Var WaitGroup Sync.Grupo de espera
para i: = 0; i < 10000; i++
grupo de espera.Agregar (1)
Ve a agregar (y WaitGroup)

grupo de espera.Esperar()
fmt.Println (x)

En el ejemplo anterior, tenemos una función que toma el valor de x y lo incrementa en 1. La función luego le dice al grupo de espera que desbloquee el mecanismo de espera utilizando la función realizada ().

Dentro de la función principal, ejecutamos al menos 10,000 goroutinas simultáneamente, cada una tratando de acceder y cambiar el valor de x.

Dado que no hay orden determinista para ejecutar las goroutinas, el valor (incremento del valor de x) de x cambia en cada ejecución.

Para resolver la condición de carrera anterior, podemos usar un mutex como se muestra a continuación:

paquete principal
importar (
"FMT"
"Sincronización"
)
var x = 1
FUNC ADD (WG *SYNC.WaitGroup, MX *Sync.Mutex)
// Bloquear acceso a este valor
mx.Cerrar con llave()
X++
mx.Desbloquear()
WG.Hecho()

func Main ()
Var WaitGroup Sync.Grupo de espera
Var mutex sincronización.Mutex
para i: = 0; i < 10000; i++
grupo de espera.Agregar (1)
Ve a agregar (y WaitGroup y Mutex)

grupo de espera.Esperar()
fmt.Println (x)

Aquí, agregamos MX de Sync de tipo.Mutex a la función agregar. Luego, bloqueamos el operador de incremento para permitir una sola goroutina a la vez.

Clausura

Este artículo cubrió los fundamentos de implementar un mutex en Go utilizando el paquete de sincronización para corregir una condición de carrera simple. Esperamos que hayas encontrado este artículo útil. Consulte otros artículos de Sugerencia de Linux para obtener más consejos e información.