Sincronización de Golang

El paquete de sincronización de Golang proporciona primitivas de sincronización, como mutex, grupo de espera, piscina, lectura y escritura mutex y variables de condición.

Explore algunas características proporcionadas en este artículo.

Golang mutex

La sincronización.Mutex proporciona un mutex primitivo, que permite exclusiones mutuas para recursos compartidos que evitan las condiciones de carrera.

Ejemplo de uso:

paquete principal
importar "sincronización"
func Main ()
var i = 10
mutex: = & sincronización.Mutex
mutex.Cerrar con llave()
// Solo una Goroutine puede acceder a este código a la vez
i++
mutex.Desbloquear()

Leer/escribir mutex

La sincronización.RWMutex proporciona un lector/escritor mutex. Ofrece métodos similares a un mutex primitivo, pero puede permitir lecturas concurrentes utilizando métodos Rlock y Runlock:

var i = 10
mutex: = & sincronización.Rwmutex
mutex.Cerrar con llave()
// Solo una Goroutine puede acceder a este código a la vez
i++
mutex.Desbloquear()
mutex.Rlock ()
i ++ // lecturas concurrentes
mutex.Runlock ()

El ejemplo anterior puede permitir que más de una goroutine lea el código. A diferencia de Sync.Mutex, que permite exactamente un lector y un escritor a la vez.

Groups de espera

La sincronización.WaitGroup se utiliza para ofrecer un mecanismo de bloqueo para las goroutinas. Usando un grupo de espera, puede bloquear la ejecución de una función hasta que todas las Goroutinas hayan terminado de ejecutar.

Funciona creando un contador que contiene el número de goroutinas para esperar. Una vez que se completa una goroutina, el contador disminuye en 1. Una vez que el contador es 0, el grupo de espera desbloquea la ejecución.

Para agregar un valor al mostrador de WaitGroup, podemos usar el método add (), que toma un valor entero.

Para eliminar una goroutina del mostrador después de la finalización, usamos el método hecho (). Por ejemplo:

paquete principal
importar (
"FMT"
"Sincronización"
)
func Main ()
WG: = & Sync.WaitGroup
para i: = 0; i < 5; i++
WG.Agregar (1)
Go Func (x int)
fmt.Printf ("Worker: %d Running \ n", x)
WG.Hecho()
(i)

WG.Esperar()

En el ejemplo anterior, aumentamos el valor del contador de grupos de espera por 1 a través del uso de la función add ().

Una vez que se completa una goroutina, disminuimos el contador por 1 usando el método hecho (). El código anterior debe devolver la salida como:

Trabajador: 4 Running
Trabajador: 2 Running
Trabajador: 1 Running
Trabajador: 3 Running
Trabajador: 0 Running

Una vez

La sincronización.Una vez primitivo, asegura que una función se ejecute solo una vez. Un ejemplo es como se muestra a continuación:

Var una vez sincronizado.Una vez
Runonce: = func ()
fmt.Println ("ejecutar una vez")

hecho: = make (cadena chan)
para i: = 0; i < 5; i++
Go func ()
una vez.Hacer (runonce)
hecho <- "Hi"
()

para i: = 0; i < 5; i++
<-done

Conclusión

Esta guía cubre algunas primitivas básicas y fundamentales proporcionadas por el paquete GO Sync. Además, se discutieron las primitivas de sincronización, como mutex, waitgroup, piscina, lectura y escritura mutex, y variables de condición. Esperamos que hayas encontrado este artículo útil. Echa un vistazo a otros artículos de Sugerencia de Linux para obtener más consejos y tutoriales.