Lección 29 de 36 · Concurrencia: lo que PHP no tiene✦ WebMCP implementado
sync: Mutex, WaitGroup y atomic
10 min de lectura3 retos
Cuando varias goroutines tocan la misma variable a la vez, se pisan y los datos se corrompen en silencio. En PHP nunca te pasó porque cada petición tiene su propia memoria. En esta lección ves el problema, lo cazas con -race y lo arreglas con las herramientas del paquete sync: Mutex, WaitGroup y atomic.
¿De dónde vienen los nombres?
Mutex = mutual exclusion (exclusión mutua)
Un candado: mientras una goroutine lo tiene, las demás esperan. En PHP lo más parecido es flock() sobre un fichero o un SELECT ... FOR UPDATE en la BD.
RWMutex = Read/Write (lectura/escritura) + mutex
Un candado que deja leer a muchos a la vez, pero escribir solo a uno. Es el LOCK_SH (compartido) frente al LOCK_EX (exclusivo) de flock().
atomic = Del griego átomos, «que no se puede dividir»
Operaciones que se hacen de una sola vez, sin que nadie pueda colarse a mitad. En PHP lo más cercano es el INCR de Redis.
-race = race (carrera), de data race
La opción que activa el detector de carreras de datos al compilar: go run -race, go test -race. PHP no lo necesita y no lo tiene.
En 4 ideas
1/4
Si dos goroutines escriben la misma variable a la vez hay una carrera de datos: el resultado depende de la suerte. En PHP no pasa porque cada petición tiene su propia memoria (shared nothing, no se comparte nada).
sync.Mutex es un candado: mu.Lock() y defer mu.Unlock() dejan pasar a una goroutine cada vez. En PHP es flock($f, LOCK_EX) con su LOCK_UN en un finally.
sync.WaitGroup espera a un grupo: wg.Go(f) en Go 1.25, o wg.Add(1)antes del go y defer wg.Done() dentro. En PHP, el bucle que espera en curl_multi_exec().
Para un simple contador, atomic.Int64 con Add y Load es más rápido que un Mutex. Y go test -race caza las carreras antes que tus usuarios. En PHP lo más cercano a un contador atómico es el INCR de Redis.
1 · Carreras de datos
Imagina dos cocineros que llevan la cuenta de platos servidos en la misma pizarra. Los dos leen «41» a la vez, los dos suman uno y los dos escriben «42». Se han servido dos platos y la pizarra solo cuenta uno. Eso es una carrera de datos (data race).
hechas++ parece una sola cosa, pero son tres pasos: leer el valor, sumar uno y escribir el resultado. Si dos goroutines hacen esos pasos a la vez, se pisan:
Gomain.go
hechas := 0var wg sync.WaitGroupforrange1000 {
wg.Go(func() {
// Leer, sumar y escribir: otra goroutine puede colarse en medio.
hechas++
})
}
wg.Wait()
fmt.Println("Tareas hechas:", hechas)
Lo traicionero es que casi siempre sale bien. Ejecutado tres veces seguidas, este programa imprimió las tres Tareas hechas: 1000. Con el detector de carreras activado (lo ves al final de la lección), salió esto:
$ go run -race main.go
==================
WARNING: DATA RACE
Read at 0x00c0000140d8 by goroutine 8:
main.main.func1()
/m/race/main.go:13 +0x2c
Previous write at 0x00c0000140d8 by goroutine 62:
main.main.func1()
/m/race/main.go:13 +0x3c
...
Tareas hechas: 990
Found 2 data race(s)
exit status 66
Diez tareas perdidas. En producción, con más carga y más núcleos, el fallo sale cuando menos te lo esperas y no se puede repetir a voluntad.
¿Por qué? · En PHP no existe
¿Por qué en PHP nunca necesitaste esto? En PHP no existe
PHP sigue el modelo shared nothing (no se comparte nada): cada petición tiene su propio proceso con su propia memoria y, al terminar, se borra todo. Dos peticiones nunca leen la misma variable de PHP, así que no pueden pisarse dentro de PHP.
Las carreras de PHP están fuera: dos peticiones que leen el mismo saldo de la BD y lo escriben a la vez. Por eso existen las transacciones, SELECT ... FOR UPDATE y flock().
En Go todas las goroutines viven en el mismo programa y comparten memoria. Es lo que lo hace rápido (sin Redis para una caché) y lo que obliga a proteger lo compartido. sync te da las herramientas y -race te avisa si se te olvida.
2 · Mutex: un candado para lo compartido
Un Mutex es el pestillo del baño: el que entra lo echa (Lock) y los demás esperan en la puerta hasta que sale y lo quita (Unlock). Todo lo que pasa entre Lock y Unlock lo hace una sola goroutine a la vez.
PHP 8.5siguiente-id.php
<?phpdeclare(strict_types=1);
// Dos peticiones a la vez podrían pisarse al sacar el siguiente ID.// PHP bloquea el FICHERO (o la fila, con SELECT ... FOR UPDATE).functionsiguienteId(string $fichero): int
{
$f = fopen($fichero, "c+");
// Solo un proceso a la vez pasa de aquíflock($f, LOCK_EX);
try {
$siguiente = (int) stream_get_contents($f) + 1;
ftruncate($f, 0);
rewind($f);
fwrite($f, (string) $siguiente);
return$siguiente;
} finally {
// Suelta el candado pase lo que paseflock($f, LOCK_UN);
fclose($f);
}
}
echosiguienteId(__DIR__ . "/ultimo-id.txt") . PHP_EOL;
Gomain.go
package main
import (
"fmt""sync"
)
// El candado va junto a los datos que protege.typeRepositoriostruct {
mu sync.Mutex
ultimoID int
tareas map[int]string
}
// Receptor puntero: el Mutex no se puede copiar.func (r *Repositorio) Guardar(titulo string) int {
// En PHP: flock($f, LOCK_EX);
r.mu.Lock()
// En PHP: el finally con flock($f, LOCK_UN);defer r.mu.Unlock()
r.ultimoID++
r.tareas[r.ultimoID] = titulo
return r.ultimoID
}
funcmain() {
repo := &Repositorio{tareas: map[int]string{}}
var wg sync.WaitGroupfor i := range100 {
wg.Go(func() {
repo.Guardar(fmt.Sprintf("Tarea %d", i))
})
}
wg.Wait()
fmt.Println("Tareas guardadas:", len(repo.tareas))
fmt.Println("Último ID:", repo.ultimoID)
}
Equivalencia POO · PHP → Go
PHP no tiene synchronized ni candados en memoria: el candado de Go es un campo más del struct, junto a lo que protege.
PHP
Go
Quién lo ve
private int $ultimoId;
ultimoID int (minúscula)
Solo el paquete: nadie de fuera lo toca sin pasar por Guardar
flock($f, LOCK_EX) en el método
mu sync.Mutex como campo + r.mu.Lock()
Solo el paquete; el valor cero ya es un candado abierto, sin constructor
try { … } finally { flock($f, LOCK_UN); }
defer r.mu.Unlock()
Se ejecuta al salir de la función, por cualquier return
public function guardar() con $this
func (r *Repositorio) Guardar(...)
Público; con receptor puntero, porque un Mutex copiado es otro candado distinto
Si muchas goroutines leen y pocas escriben (una caché de tareas, por ejemplo), usa sync.RWMutex:
Método
Para qué
En PHP (flock)
mu.Lock() / mu.Unlock()
Escribir: entra uno y nadie más
LOCK_EX (exclusivo)
mu.RLock() / mu.RUnlock()
Leer: entran todos los lectores a la vez
LOCK_SH (compartido)
3 · WaitGroup a fondo
Ya usaste wg.Go en la primera lección. Por dentro, un WaitGroup es un contador con tres operaciones, y en mucho código verás la forma larga:
Gomain.go
package main
import (
"fmt""sync"
)
funcmain() {
tareas := []string{"Comprar pan", "Llamar al banco", "Repasar Go"}
hechas := make([]string, len(tareas))
var wg sync.WaitGroupfor i, t := range tareas {
// Add va ANTES del go: apuntas la tarea antes de lanzarla.
wg.Add(1)
gofunc() {
// Done resta uno al terminar, pase lo que pase.defer wg.Done()
hechas[i] = "hecha: " + t
}()
}
// Wait espera a que el contador vuelva a cero.
wg.Wait()
for _, h := range hechas {
fmt.Println(h)
}
}
Método
Qué hace
En la libreta del jefe de cocina
wg.Add(n)
Suma n al contador
Apunta n platos
wg.Done()
Resta uno
Tacha un plato
wg.Wait()
Espera hasta que el contador sea cero
No cierra hasta tenerlo todo tachado
wg.Go(f) (Go 1.25)
Add(1) + go + defer Done() en una línea
Apunta, encarga y tacha solo
El error clásico es poner el Adddentro de la goroutine:
Gomain.go
for _, t := range tareas {
gofunc() {
// MAL: cuando main llegue a Wait, puede que esta línea aún no se haya ejecutado.
wg.Add(1)
defer wg.Done()
procesar(t)
}()
}
// Si el contador todavía es 0, Wait no espera a nadie.
wg.Wait()
4 · atomic: contadores sin candado
Para algo tan simple como sumar uno, echar el candado es como cerrar la cocina entera para apuntar un número. El paquete sync/atomic hace la suma de un solo golpe: nadie puede colarse entre el leer y el escribir.
Gomain.go
package main
import (
"fmt""sync""sync/atomic"
)
funcmain() {
// El valor cero ya vale 0: no necesita constructor.var hechas atomic.Int64var wg sync.WaitGroupforrange1000 {
wg.Go(func() {
// En PHP (con Redis): $redis->incr("hechas");
hechas.Add(1)
})
}
wg.Wait()
// Load lee el valor de forma segura.
fmt.Println("Tareas hechas:", hechas.Load())
}
Herramienta
Cuándo
En PHP
atomic.Int64, atomic.Bool…
Un número o un interruptor sueltos
INCR de Redis
sync.Mutex
Varios campos que cambian juntos (ID + mapa)
flock() o una transacción
Un canal
Pasar datos de una goroutine a otra
Una cola (Redis, RabbitMQ)
5 · El detector de carreras: -race
Go trae de serie un detector de carreras: al compilar con -race, el programa vigila cada lectura y escritura de memoria y te avisa si dos goroutines tocan lo mismo sin protección, con el fichero y la línea de cada una. Es como poner una cámara en la cocina.
$ go run -race main.go
$ go test -race ./...
Solo ve las carreras que ocurren mientras se ejecuta: tus tests tienen que lanzar goroutines de verdad.
El programa va varias veces más lento y gasta más memoria: úsalo en tests y en desarrollo, no en producción.
Ponlo en tu integración continua: go test -race ./... en cada push.
En el playground de esta web no se pueden pasar opciones al compilador: pruébalo en tu máquina.
La pregunta que te vas a hacer
«Vale, pero… ¿y si mi API corre en dos servidores?»
Un Mutex solo protege dentro de un programa. Si arrancas dos copias de tu API (dos contenedores, dos máquinas), cada una tiene su propio candado y no se ven. Para eso sigues usando lo mismo que en PHP: transacciones y SELECT ... FOR UPDATE en la BD, restricciones UNIQUE o un candado en Redis.
Regla práctica: el Mutex protege la memoria de tu programa (cachés, contadores, mapas); la BD protege los datos de todos.
Guardar(titulo string) int lee el último ID, espera a la BD (simulada con 1 ms) y escribe el siguiente. Con 20 goroutines guardando a la vez, todas leen el mismo ID y se pisan. Protege todo el método con el Mutex que ya tiene el struct (r.mu.Lock() y defer r.mu.Unlock()). Es el flock($f, LOCK_EX) de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Al principio de Guardar, dos líneas: r.mu.Lock() y defer r.mu.Unlock(). Así ninguna goroutine lee el ID hasta que la anterior ha terminado de escribirlo.
Reto 2 de 3 · ✓ Resuelto
No te vayas sin esperar
ProcesarTodas(ids []int, procesar func(int)) lanza una goroutine por ID, pero vuelve antes de que terminen: quien la llama cree que ya está todo hecho y no es verdad. Haz que espere a todas con un sync.WaitGroup (mejor con wg.Go). Tienen que seguir yendo a la vez: con 10 IDs que tardan 20 ms cada uno, debe tardar menos de 150 ms. En PHP sería el bucle que espera en curl_multi_exec().
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Importa sync, crea var wg sync.WaitGroup, cambia go procesar(id) por wg.Go(func() { procesar(id) }) y añade wg.Wait() después del for.
Reto 3 de 3 · ✓ Resuelto
Estadísticas atómicas
Estadisticas cuenta tareas creadas y completadas desde muchas goroutines con dos atomic.Int64. Crear() ya funciona. Completa Completar() para que sume uno a completadas y arregla Pendientes() int64 para que devuelva creadas menos completadas. Con 100 Crear() y 40 Completar() a la vez debe dar 60. En PHP serían dos INCR de Redis y una resta.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. En Completar, e.completadas.Add(1). En Pendientes, lee los dos con Load() y réstalos.
Resumen
Lo que te llevas de esta lección
Dos goroutines escribiendo lo mismo = carrera de datos; casi siempre sale bien y por eso es peligrosa (en PHP no pasa: shared nothing).
mu.Lock() + defer mu.Unlock() justo debajo (en PHP, flock($f, LOCK_EX) con LOCK_UN en el finally).
El Mutex va como campo junto a lo que protege, con receptor puntero (en PHP, una propiedad private).
wg.Go(f), o wg.Add(1)antes del go y defer wg.Done() dentro; wg.Wait() espera a todas.
Un contador suelto: atomic.Int64 con Add y Load (en PHP, el INCR de Redis).
go test -race ./... caza las carreras antes que tus usuarios (PHP no tiene nada parecido).
Para recordarlo: «Echa el pestillo y deja dicho que lo quiten»
mu.Lock() echa el pestillo y, en la línea siguiente, defer mu.Unlock() deja dicho que se quite al salir, pase lo que pase. Si lo quitas a mano al final, el primer return de en medio deja a todos esperando en la puerta.