Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 29 de 36 · Concurrencia: lo que PHP no tiene ✦ WebMCP implementado

sync: Mutex, WaitGroup y atomic

10 min de lectura 3 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).

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 := 0
var wg sync.WaitGroup
for range 1000 {
    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
<?php
declare(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).
function siguienteId(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 pase
        flock($f, LOCK_UN);
        fclose($f);
    }
}

echo siguienteId(__DIR__ . "/ultimo-id.txt") . PHP_EOL;
Gomain.go
package main

import (
    "fmt"
    "sync"
)

// El candado va junto a los datos que protege.
type Repositorio struct {
    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
}

func main() {
    repo := &Repositorio{tareas: map[int]string{}}

    var wg sync.WaitGroup
    for i := range 100 {
        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.

PHPGoQuié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étodomu 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 $thisfunc (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étodoPara quéEn PHP (flock)
mu.Lock() / mu.Unlock()Escribir: entra uno y nadie másLOCK_EX (exclusivo)
mu.RLock() / mu.RUnlock()Leer: entran todos los lectores a la vezLOCK_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"
)

func main() {
    tareas := []string{"Comprar pan", "Llamar al banco", "Repasar Go"}
    hechas := make([]string, len(tareas))

    var wg sync.WaitGroup
    for i, t := range tareas {
        // Add va ANTES del go: apuntas la tarea antes de lanzarla.
        wg.Add(1)
        go func() {
            // 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étodoQué haceEn la libreta del jefe de cocina
wg.Add(n)Suma n al contadorApunta n platos
wg.Done()Resta unoTacha un plato
wg.Wait()Espera hasta que el contador sea ceroNo cierra hasta tenerlo todo tachado
wg.Go(f) (Go 1.25)Add(1) + go + defer Done() en una líneaApunta, encarga y tacha solo

El error clásico es poner el Add dentro de la goroutine:

Gomain.go
for _, t := range tareas {
    go func() {
        // 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"
)

func main() {
    // El valor cero ya vale 0: no necesita constructor.
    var hechas atomic.Int64

    var wg sync.WaitGroup
    for range 1000 {
        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())
}
HerramientaCuándoEn PHP
atomic.Int64, atomic.Bool…Un número o un interruptor sueltosINCR de Redis
sync.MutexVarios campos que cambian juntos (ID + mapa)flock() o una transacción
Un canalPasar datos de una goroutine a otraUna 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.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Protege el repositorio

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

Resumen

Lo que te llevas de esta lección

  1. Dos goroutines escribiendo lo mismo = carrera de datos; casi siempre sale bien y por eso es peligrosa (en PHP no pasa: shared nothing).
  2. mu.Lock() + defer mu.Unlock() justo debajo (en PHP, flock($f, LOCK_EX) con LOCK_UN en el finally).
  3. El Mutex va como campo junto a lo que protege, con receptor puntero (en PHP, una propiedad private).
  4. wg.Go(f), o wg.Add(1) antes del go y defer wg.Done() dentro; wg.Wait() espera a todas.
  5. Un contador suelto: atomic.Int64 con Add y Load (en PHP, el INCR de Redis).
  6. 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.