¿Cómo manejar lecturas y escrituras concurrentes en Go?
Cuando hablamos de concurrencia en programación, siempre surge la preocupación acerca de las condiciones de carrera, especialmente al manejar variables compartidas. En el contexto de Go, surge una pregunta interesante: ¿Es necesario bloquear las lecturas cuando estamos escribiendo en la misma variable? Es un interrogante esencial al considerar operaciones bancarias, por ejemplo, depósitos simultáneos y consultas de saldo.
Aunque las escrituras deben finalizar para asegurar que los datos sean consistentes, las lecturas no siempre necesitan esperar. Go presenta una solución elegante para manejar múltiples lectores y un único escritor usando un mecanismo llamado RWMutex.
¿Cómo implementar un RWMutex en Go?
Un RWMutex es un tipo de log que permite múltiples lectores simultáneos, mientras que asegura que solo un escritor pueda operar en un momento dado. Esto optimiza la concurrencia, ya que no es necesario bloquear las lecturas cuando alguien está escribiendo.
Por ejemplo, al modificar nuestro programa de depósitos, la implementación del RWMutex implica sustituir el mutex en las funciones de lectura y escritura. Veámoslo en un código simplificado:
var mu sync.RWMutex // Definimos el RWMutexfuncdeposit(amount int){ mu.Lock()// Bloqueamos la escritura balance += amount
mu.Unlock()// Desbloqueamos después de escribir}funcgetBalance()int{ mu.RLock()// Bloqueamos solo para lectura b := balance
mu.RUnlock()// Desbloqueamos la lecturareturn b
}
Con este enfoque, múltiples goroutines pueden leer el saldo sin bloqueos, aunque solo una pueda escribir a la vez. Esto evita el bloqueo innecesario en las funciones de lectura, mientras que garantiza la seguridad de las escrituras.
¿Cuáles son los beneficios del RWMutex?
Implementar un RWMutex en un escenario concurrente trae varios beneficios:
Concurrencia mejorada: Permite que múltiples procesos lean al mismo tiempo sin interferir.
Evita bloqueos innecesarios: Las lecturas no bloquean las escrituras, permitiendo consultas más rápidas.
Seguridad en escritura: Solo se permite una escritura a la vez, previniendo condiciones de carrera.
Escalabilidad: Especialmente útil en aplicaciones donde las lecturas son mucho más frecuentes que las escrituras.
En resumen, el RWMutex es una herramienta poderosa en Go para optimizar operaciones concurrentes, permitiendo múltiples operaciones de lectura y asegurando la integridad de las escrituras. Este paradigma es ideal para sistemas donde las consultas son prioritarias y se requiere eficiencia y consistencia. Invierte tiempo en interiorizar estos conceptos y apliquémoslos en contextos más complejos, como sistemas de caché concurrente, asegurando programas robustos y eficientes.
¿Cómo manejar lecturas y escrituras concurrentes en Go?
Cuando hablamos de concurrencia en programación, siempre surge la preocupación acerca de las condiciones de carrera, especialmente al manejar variables compartidas. En el contexto de Go, surge una pregunta interesante: ¿Es necesario bloquear las lecturas cuando estamos escribiendo en la misma variable? Es un interrogante esencial al considerar operaciones bancarias, por ejemplo, depósitos simultáneos y consultas de saldo.
Aunque las escrituras deben finalizar para asegurar que los datos sean consistentes, las lecturas no siempre necesitan esperar. Go presenta una solución elegante para manejar múltiples lectores y un único escritor usando un mecanismo llamado RWMutex.
¿Cómo implementar un RWMutex en Go?
Un RWMutex es un tipo de log que permite múltiples lectores simultáneos, mientras que asegura que solo un escritor pueda operar en un momento dado. Esto optimiza la concurrencia, ya que no es necesario bloquear las lecturas cuando alguien está escribiendo.
Por ejemplo, al modificar nuestro programa de depósitos, la implementación del RWMutex implica sustituir el mutex en las funciones de lectura y escritura. Veámoslo en un código simplificado:
var mu sync.RWMutex // Definimos el RWMutex
func deposit(amount int) {
mu.Lock() // Bloqueamos la escritura
balance += amount
mu.Unlock() // Desbloqueamos después de escribir
}
func getBalance() int {
mu.RLock() // Bloqueamos solo para lectura
b := balance
mu.RUnlock() // Desbloqueamos la lectura
return b
}
Con este enfoque, múltiples goroutines pueden leer el saldo sin bloqueos, aunque solo una pueda escribir a la vez. Esto evita el bloqueo innecesario en las funciones de lectura, mientras que garantiza la seguridad de las escrituras.
¿Cuáles son los beneficios del RWMutex?
Implementar un RWMutex en un escenario concurrente trae varios beneficios:
Concurrencia mejorada: Permite que múltiples procesos lean al mismo tiempo sin interferir.
Evita bloqueos innecesarios: Las lecturas no bloquean las escrituras, permitiendo consultas más rápidas.
Seguridad en escritura: Solo se permite una escritura a la vez, previniendo condiciones de carrera.
Escalabilidad: Especialmente útil en aplicaciones donde las lecturas son mucho más frecuentes que las escrituras.
En resumen, el RWMutex es una herramienta poderosa en Go para optimizar operaciones concurrentes, permitiendo múltiples operaciones de lectura y asegurando la integridad de las escrituras. Este paradigma es ideal para sistemas donde las consultas son prioritarias y se requiere eficiencia y consistencia. Invierte tiempo en interiorizar estos conceptos y apliquémoslos en contextos más complejos, como sistemas de caché concurrente, asegurando programas robustos y eficientes.
Solo para aclarar las diferencias entre RWLock y no usar nada:
Lock bloquea lecturas (con RLock) y escrituras (con Lock) de otras goroutines
Unlock permite nuevas lecturas (con Rlock) y/o otra escritura (con Lock)
RLock bloquea escrituras (Lock) pero no bloquea lecturas (RLock)
RUnlock permite nuevas escrituras (y también lecturas, pero por la naturaleza de RLock, estas no se vieron bloqueadas nunca)
En esencia, RLock de RWLock garantiza una secuencia de lecturas en donde el valor que lees no se verá alterado por nuevos escritores, a diferencia de no usar nada.
Refactoricé el ejemplo para que se muestre el balance en cada iteración del ciclo, se puede evidenciar que las lecturas se realizan mucho más rápido que las escrituras. Esto es esperable por tener muchas go routinas leyendo al mismo tiempo, pero solo una escribiendo a la vez.
La cuenta arranca con cero y va sumando i desde 1 hasta 20, segun la fórmula de Gauss la cuenta debe dar 210.
package main
import (
"fmt"
"sync"
)
var (
balance int = 0
)
// Writer
func Deposit(amount int, wg *sync.WaitGroup, lock *sync.RWMutex) {
defer wg.Done()
defer lock.Unlock()
lock.Lock()
b := balance
balance = b + amount
}
// Reader
func Balance(wg *sync.WaitGroup, lock *sync.RWMutex) {
defer wg.Done()
defer lock.RUnlock()
lock.RLock()
b := balance
fmt.Println("Current balance is", b)
}
func main() {
var wg sync.WaitGroup
var lock sync.RWMutex
for i := 1; i <= 20; i++ {
wg.Add(1)
go Deposit(i, &wg, &lock)
wg.Add(1)
go Balance(&wg, &lock)
}
wg.Wait()
fmt.Println("Finished with balance", balance)
}
Obtiene como salida:
Current balance is 3
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 6
Current balance is 11
Current balance is 11
Current balance is 11
Current balance is 11
Current balance is 11
Current balance is 11
Current balance is 11
Finished with balance 210
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.RWMutex) {
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(lock *sync.RWMutex) int {
lock.RLock()
b := balance
lock.RUnlock()
return b
}
// 1 Deposit() -> Escribir (Race Condition)
// N Balance() -> Leer
func main() {
var wg sync.WaitGroup
var lock sync.RWMutex // 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(&lock))
}
Profe, una pregunta, si tengo un Rlock para tener N Lectores yo podria obviar el uso de los RLock? lo digo porque si solo vamos a leer creo que no seria necesario bloquear, aunque talvez se me haya pasado algo de largo, agradezco mucho su consejo para seguir con las buenas practicas. un saludo.
A ver si entiendo. Yo elijo si el bloque es de lectura o de escritura según el sentido del código por supuesto.
Los bloques de codigo bloqueados con RLock bloquean a los bloques bloqueados con RWLock. Y los bloques bloqueados con RWLock bloquean todos los bloques que usen esa variable Mutex..
como podemos ver en este ejemplo, que como solo necesitamos en un deposito garantizar que para que comience una acción de deposito, la acciones que ejercen cambios en estas variables terminen su lógica antes de que comience de nuevo una acción de deposito. Por lo tanto esta función no la necesito modificar. el uso de Lock() y Unlock() es correcto.
Pero para el caso de Balance su lógica es distinta, Por lo que al bloquearlos con Lock() y Unlock() no permito ni la Escritura y Lectura. Quiere decir que mientras se este ejercicio alguna acción o cambios sobre su variable de lectura. No podrá ingresar a la info, para leerla mientras alguien se encuentre ejerciendo un deposito. Por lo tanto no estaríamos resolviendo el erro de dejarla como estaba sin el uso de Lock() y Unlock() en Balance(). Por que si no puedes a acceder a cambios de información actual y que el estado final dependa de que complete cierto bloque de código mas no solo una parte entonces puedo tomar un dato que no corresponda. Debido que no le estaríamos dando restricciones a Balance. Por lo tanto aplicamos restricciones respecto a las acciones.
func Balance(lock *sync.RWMutex) int {
lock.RLock()
b := balance // solo estamos leyendo balance. por lo contrario en lo que pasa en Deposit.
lock.RUnlock() // garantizo que mientras el valor termine de ejecutarse va aun mantener el estado anterior.
return b
}
Le estamos dando permisos de lectura mientras su permiso de escritura se encuentra bloqueado. Por lo que estamos permitiendo tener diferentes lectores sin que sean bloqueados.
Hice un refactor del codigo imprimiendo en cada iteracion el balance para asi usar rwmutex
package main
import (
"fmt"
"sync"
)
var balance = 100
func Deposit(amount int, wg *sync.WaitGroup, lock *sync.RWMutex) {
defer wg.Done()
lock.Lock()
b := balance
balance = amount + b
lock.Unlock()
}
func Balance(lock *sync.RWMutex) int {
lock.RLock()
b := balance
lock.RUnlock()
return b
}
func main() {
var wg sync.WaitGroup
var lock sync.RWMutex
for i := 1; i <= 5; i++ {
wg.Add(1)
go Deposit(i*100, &wg, &lock)
fmt.Println("The Current balance is: ", Balance(&lock))
}
wg.Wait()
}
Me parece interesante cómo el uso de RWMutex muestra que no toda sincronización tiene que ser restrictiva. Permitir múltiples lectores mientras se controla la escritura es una optimización muy parecida a lo que pasa en sistemas reales como cachés, bases de datos o incluso sistemas de inventario donde hay muchas consultas y pocas actualizaciones.
Creo que el reto real no es solo saber usar Lock o RLock, sino identificar el patrón de acceso a los datos (muchas lecturas vs muchas escrituras) para decidir qué estrategia usar.
¿En qué tipo de aplicaciones creen que RWMutex realmente marque una diferencia notable frente a un Mutex normal?