¿Cómo podemos manejar la condición de carrera en Go?
La programación concurrente en Go nos permite realizar múltiples tareas a la vez, incrementando la eficiencia de nuestros programas. Sin embargo, esto también puede llevar a problemas si no se manejan adecuadamente los accesos compartidos a las variables. Uno de estos problemas es la condición de carrera, un fenómeno donde múltiples rutinas acceden y manipulan datos compartidos al mismo tiempo, causando comportamientos incorrectos o inconsistentes.
¿Cómo podemos identificar una condición de carrera?
Para empezar, Go ofrece una herramienta para detectar condiciones de carrera. Podemos utilizar la bandera --race al compilar nuestro programa. Esta simple acción nos dará un aviso si el compilador detecta subrutinas accediendo indeciblemente a variables compartidas. La detección temprana es crucial para evitar problemas en producción.
go run --race main.go
¿Cómo podemos evitar una condición de carrera en Go?
Manejando adecuadamente las condiciones de carrera, podemos asegurar la integridad de los datos. Un enfoque común es utilizar locks o candados. En Go, podemos utilizar la estructura sync.Mutex que actúa como un candado que regula el acceso a las variables compartidas.
Implementación básica de locks en Go
Definir un Mutex: Primero, definimos un sync.Mutex en nuestro programa, que usaremos para controlar el acceso.
var mu sync.Mutex
Bloquear y desbloquear el acceso: Dentro de las funciones que modifican los datos compartidos, utilizamos los métodos Lock y Unlock de Mutex para bloquear y desbloquear el acceso a las variables.
funcdepositar(amount int){ mu.Lock() b := balance
balance = b + amount
mu.Unlock()}
Este código garantiza que solo una go rutina pueda modificar el balance a la vez, evitando por ende la condición de carrera.
¿Qué ocurre si solo realizamos lecturas?
Aunque el uso de sync.Mutex soluciona los problemas de concurrencia en operaciones de escritura, puede resultar ineficiente para operaciones que solo requieren lectura. En estos casos, donde no estamos modificando los datos, hay otro tipo de lock en Go más apropiado llamado sync.RWMutex. Este permite múltiples lecturas concurrentes pero restringe el acceso total al realizar una escritura. Lo exploraremos más en profundidad en las siguientes lecciones.
Evitar Condiciones de Carrera en Go con Mutex y WaitGroup
¿Cómo podemos manejar la condición de carrera en Go?
La programación concurrente en Go nos permite realizar múltiples tareas a la vez, incrementando la eficiencia de nuestros programas. Sin embargo, esto también puede llevar a problemas si no se manejan adecuadamente los accesos compartidos a las variables. Uno de estos problemas es la condición de carrera, un fenómeno donde múltiples rutinas acceden y manipulan datos compartidos al mismo tiempo, causando comportamientos incorrectos o inconsistentes.
¿Cómo podemos identificar una condición de carrera?
Para empezar, Go ofrece una herramienta para detectar condiciones de carrera. Podemos utilizar la bandera --race al compilar nuestro programa. Esta simple acción nos dará un aviso si el compilador detecta subrutinas accediendo indeciblemente a variables compartidas. La detección temprana es crucial para evitar problemas en producción.
go run --race main.go
¿Cómo podemos evitar una condición de carrera en Go?
Manejando adecuadamente las condiciones de carrera, podemos asegurar la integridad de los datos. Un enfoque común es utilizar locks o candados. En Go, podemos utilizar la estructura sync.Mutex que actúa como un candado que regula el acceso a las variables compartidas.
Implementación básica de locks en Go
Definir un Mutex: Primero, definimos un sync.Mutex en nuestro programa, que usaremos para controlar el acceso.
var mu sync.Mutex
Bloquear y desbloquear el acceso: Dentro de las funciones que modifican los datos compartidos, utilizamos los métodos Lock y Unlock de Mutex para bloquear y desbloquear el acceso a las variables.
func depositar(amount int) {
mu.Lock()
b := balance
balance = b + amount
mu.Unlock()
}
Este código garantiza que solo una go rutina pueda modificar el balance a la vez, evitando por ende la condición de carrera.
¿Qué ocurre si solo realizamos lecturas?
Aunque el uso de sync.Mutex soluciona los problemas de concurrencia en operaciones de escritura, puede resultar ineficiente para operaciones que solo requieren lectura. En estos casos, donde no estamos modificando los datos, hay otro tipo de lock en Go más apropiado llamado sync.RWMutex. Este permite múltiples lecturas concurrentes pero restringe el acceso total al realizar una escritura. Lo exploraremos más en profundidad en las siguientes lecciones.
Para ver claramente el problema de no bloquear el acceso a la variable compartida:
Si en el for en lugar de 5 pones por ejemplo 5000, la suma total es diferente en cada ejecución, variando incluso por varios millones de un resultado a otro.
Una vez que aplicas el bloqueo, el resultado ya siempre es el mismo.
Mientras más aprendo de Go más quedo asombrado del cuidado que tuvieron sus creadores. Se ve que examinaron muchos de los problemas recurrentes de otros lenguajes de programación e implementaron soluciones nativas en el lenguaje.
package main
import "sync"
// Problem: Race condition
// build: go build --race main.go
var (
balance int = 100
)
func Deposit(amount int, wg *sync.WaitGroup, lock *sync.Mutex) {
defer wg.Done()
defer lock.Unlock() // Unlock is a method of the Mutex struct
lock.Lock() // Lock the mutex
b := balance
balance = b + amount
}
func Balance() int {
b := balance
return b
}
func main() {
var wg sync.WaitGroup
var lock sync.Mutex // Mutex is a struct that implements the Lock and Unlock methods
for i := 1; i <= 5; i++ {
wg.Add(1)
go Deposit(i*100, &wg, &lock)
}
wg.Wait()
println(Balance())
}
Los WG son la forma en que podemos encargarnos de las situaciones donde necesitemos realizar procesos concurrentemente, pero esperarnos a que terminen.
Con el Add le decimos cuantas rutinas vamos a ejecutar, o más bien cuantas veces llamaremos al Done() antes de salir, finalmente gracias al Wait() bloquearemos la ejecución hasta que recibamos los Done() que habíamos indicado anteriormente.
En caso que se este suando una maquina WSL, o una virtual Linux y salga el error:
marco@myMachina:~/go/src/curso_Concurrencia&DisenoDePatrones$ go build --race src/main.go
go: -race requires cgo; enable cgo by setting CGO_ENABLED=1
La forma de mitigar dicho inconveniente y deje crear tu compilado es mediante la instalación de gcc y build-essential. Sea basada en Debian (sudo apt-get instal) o en RH (sudo yum install), u otra distribución. Espero les sirva.
Para ver claramente el problema de no bloquear el acceso a la variable compartida:
Si en el for en lugar de 5 pones por ejemplo 5000, la suma total es diferente en cada ejecución, variando incluso por varios millones de un resultado a otro.
Una vez que aplicas el bloqueo, el resultado ya siempre es el mismo.
Mientras más aprendo de Go más quedo asombrado del cuidado que tuvieron sus creadores. Se ve que examinaron muchos de los problemas recurrentes de otros lenguajes de programación e implementaron soluciones nativas en el lenguaje.
Voy en el minuto 6:53 y tuve un momento DiCaprio, no pude dejar de pensar en las transacciones de PostgreSQL (cuyo curso tome hace pocos días XD).
Al realizar éste bloqueo no se genera un cuello de botella en la concurrencia? en ese punto el programa se comporta de forma secuencial, no?
Hola NaujOyamat, muy interesante pregunta; para evitar la condición de carrera lo que se intenta alcanzar a través de los Mutex es "otorgarle el lock" a una sola GoRoutine en un momento determinado el acceso a esa variable, por eso es muy importante definir solo el bloque afectado entre el Lock y el UnLock. Claramente esto traerá problemas de rendimiento debido a que no podremos tener todas las GoRoutine que queramos trabajando al mismo tiempo si se topan con un bloque como ese.
func MyFunction() {
lock.Lock()
// Esta variable x es compartida
x = 5
// Esta lógica no depende de x pero está siendo agregada dentro del bloque lo cual va a disminuir el rendimiento
logicaComplejaQueNoDependeDeX()
logicaComplejaQueNoDependeDeX2()
lock.UnLock()
}
Y si tuvieramos más GoRoutines trabajando sobre MyFunction() prácticamente tendrían que esperar que esas lógicas se ejecuten de una "manera secuencial". Si bien usar Mutex es una herramienta muy poderosa para estos casos, debería de ser tratado con mucho cuidado ya que una aplicación errónea podría generar un desperdicio de GoRoutines.
Lo que yo entiendo es que es justo eso lo que se busca :sweat_smile:
En un programa grande no todas las GoRoutines trabajarán sobre los mismos datos, por lo que opino que con un sync.Mutex no las bloquearías todas, sino justo las que necesitas controlar para evitar conflictos.
Como dicen, un gran poder conlleva una gran responsabilidad, por lo que debes ser capaz de identificar cuando tus GoRoutines deberían comportarse de forma secuencial para evitar bloqueos, y cuando no.
package main
import"sync"// Problem: Race condition// build: go build --race main.govar( balance int =100)func Deposit(amount int, wg *sync.WaitGroup, lock *sync.Mutex){ defer wg.Done() defer lock.Unlock()// Unlock is a method of the Mutex struct lock.Lock()// Lock the mutexb:= balance
balance = b + amount
}func Balance() int {b:= balance
return b
}func main(){var wg sync.WaitGroupvar lock sync.Mutex// Mutex is a struct that implements the Lock and Unlock methodsfori:=1; i <=5; i++{ wg.Add(1) go Deposit(i*100,&wg,&lock)} wg.Wait()println(Balance())}
Para el que no le quedó claro de los WaitGroups:
Los WG son la forma en que podemos encargarnos de las situaciones donde necesitemos realizar procesos concurrentemente, pero esperarnos a que terminen.
Con el Add le decimos cuantas rutinas vamos a ejecutar, o más bien cuantas veces llamaremos al Done() antes de salir, finalmente gracias al Wait() bloquearemos la ejecución hasta que recibamos los Done() que habíamos indicado anteriormente.
Puede haber un race condition en dado caso que varias gorutinas quieran ejecutar el "lock.Lock()" al mismo tiempo?
El compilador se encarga de que cada rutina bloquee el programa de acuerdo en el orden en que van accediendo al recurso.
Super interesante esta clase, me ha llamado mucho la atención...
Si colocan el Lock() y se olvidan el Unlock() el programa puede quedar en deadlock o "Abrazo mortal"
Hola a todos!
En caso que se este suando una maquina WSL, o una virtual Linux y salga el error:
marco@myMachina:~/go/src/curso_Concurrencia&DisenoDePatrones$ go build --race src/main.gogo:-race requires cgo; enable cgo by setting CGO_ENABLED=1
La forma de mitigar dicho inconveniente y deje crear tu compilado es mediante la instalación de gcc y build-essential. Sea basada en Debian (sudo apt-get instal) o en RH (sudo yum install), u otra distribución. Espero les sirva.
en mi caso me toco instalar PERO aun así al ejecutar: go build --race src/main.go no muestra nada y al ejecutarlo con run
go run -race src/main.go
sale exit status 0xc0000139
al final la solución que halle fue descargar de extraerlo en
D:\PROGRAMAS
agregarlo al path en variables del sistema
D:\PROGRAMAS\mingw64\bin
reiniciar terminales
al ejecutar el comando agrego al inicio CGO_ENABLED=1 quedando haci
CGO_ENABLED=1 go build -race main.go
y funciono correctamente
Pudiese poner Defer lock.Unlock() sabiendo que el defer se ejecuta al final de la funcion? func Deposit(amount int, wg *sync.WaitGroup, lock *sync.Mutex) { defer wg.Done() lock.Lock() defer lock.Unlock() // ¡Aquí está! b := balance balance = b + amount }
func Deposit(amount int, wg *sync.WaitGroup, lock *sync.Mutex){ defer wg.Done() lock.Lock() defer lock.Unlock()b:= balance
balance = b + amount
}
Les dejo éste material:
Tengo una duda con Mutex, cuando hacemos Lock y hasta que hacemos Unlock, eliminamos también la característica clave de asincronismo de nuestro programa?
Es decir, entiendo que con wait group estamos eliminando ya de por si el asincronismo para esperar a que nuestro programa termine, pero en caso de estar desarrollando una API, lo ideal sería no bloquear el programa en algunos casos concurrentes para que el usuario no sienta la "espera", pregunto sin con el bloqueo de variables eliminamos esta posibilidad?
Los locks solo bloquean al momento de leer/escribir, lo cual es una fracción de tiempo mínima, muy pequeña, que sirve para la coordinación de las goroutines con el fin de evitar las condiciones de carrera. Entonces realmente no es que estes eliminando la concurrencia.
Se puede verificar el valor que esperamos de resultado usando la fórmula de Gauss. 1+2+3+...+n=n(n+1)/2.
here's my code
package main
import("fmt""sync")var balance int =100func Deposit(amount int, wg *sync.WaitGroup, mutex *sync.Mutex){ mutex.Lock() balance += amount
mutex.Unlock() defer wg.Done()}func WithDraw(amount int, wg *sync.WaitGroup, mutex *sync.Mutex){ mutex.Lock()if balance < amount { fmt.Println("Not enough balance") mutex.Unlock() wg.Done()return} balance -= amount
mutex.Unlock() defer wg.Done()}func Balance() int {return balance
}func main(){var wg sync.WaitGroupvar mutex sync.Mutexfori:=1; i <=5; i++{ wg.Add(1) go Deposit(i*100,&wg,&mutex)} wg.Add(1) go WithDraw(500,&wg,&mutex) wg.Wait() fmt.Printf("Balance: %d\n", balance)}
Era necesario incluir la definición de la variable b := balance en la función Deposit dentro del lock (?)
Viendo esta clase me pregunto el sentido de usar concurrencia si terminamos bloqueando las otras Go rutinas, tal vez este ejemplo es muy sencillo pero creo que usar mal el lock puede quitarle un poco el sentido a la concurrencia.
Es verdad que el lock genera un bloqueo, sin embargo si puedes notar, son bloqueos que podemos establecer en lineas específicas del código, (la idea no es bloquear toda la gorutine). Es decir, no es lo mismo ejecutar e una sola rutina dos depositos que crear 2 goroutines para cada deposito y bloquear solamente las lineas en donde se modifica la información que comparten entre ellas. Sigue siendo mucho mas eficiente hacer uso de la concurrencia en este tipo de escenarios. Lo que sucede es que por la sencilles del ejemplo no se percibe tanto la ventaja de usar las gorutines y el mutex al mismo tiempo, puesto que la idea de Nestor es que entendamos con un ejemplo sencillo como podemos enfrentar esta condición por medio del Lock() y Unlock()
Cómo podemos saber dónde colocar el lock y el unlock? Puede ser en asignaciones y en condicionales?
Les comparto los apuntes que hago en mi código
Resumen:
Al ejecutar varias Goroutines que modifiquen el mismo recurso,
en este caso balance, hay altas probabilidades de obtener un error de carrera,
con lock, podemos bloquear un pedasito de codigo, donde se esta modifcando el recurso
mientras cada goroutine hace la modificación y desbloquea
Error de Carrera (race condition):
pueden ocurrir cuando dos o más hilos intentan acceder y modificar simultáneamente
datos compartidos sin la debida sincronización, lo que puede dar lugar a resultados
inesperados o incorrectos.
Comando para evaluar el riesgo de "Condición de Carrera"
go build --race synch/main.go
La bandera --race también sirve con el go run y el go test, jóvenes.