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 27 de 36 · Concurrencia: lo que PHP no tiene ✦ WebMCP implementado

Goroutines: de un proceso por petición a miles de tareas

9 min de lectura 3 retos

En PHP cada petición vive en su propio proceso y hace las cosas de una en una. En Go, un mismo programa puede tener miles de tareas en marcha a la vez: las goroutines. En esta lección lanzas las primeras con la palabra go y aprendes a esperar a que terminen.

¿De dónde vienen los nombres?

goroutine = Go + coroutine (corrutina)
Juego de palabras de los autores de Go: una función que corre a la vez que las demás. Eligieron un nombre nuevo porque «hilo», «proceso» o «corrutina» ya significaban otra cosa. En PHP lo más parecido son las Fiber de PHP 8.1, pero esas no corren a la vez de verdad.
sync = synchronization (sincronización)
El paquete con las herramientas para coordinar goroutines. En PHP no existe porque cada petición va por su lado.
WaitGroup = wait (esperar) + group (grupo)
Un contador de tareas pendientes: esperas a todo el grupo. Lo más parecido en PHP es el bucle de curl_multi_exec() que espera a que terminen todas las peticiones.
GOMAXPROCS = Go + max (máximo) + procs (processors, procesadores)
Cuántos núcleos de la CPU ejecutan código Go a la vez. Por defecto, todos los que tiene la máquina. En php-fpm lo más parecido es pm.max_children, pero ese cuenta procesos, no núcleos.
En 4 ideas
1/4

PHP atiende una petición por proceso: php-fpm arranca varios procesos (los workers) y cada uno hace su trabajo de principio a fin sin compartir nada. Go hace lo contrario: un solo programa reparte el trabajo en goroutines.

1 · PHP: una petición, un proceso

Hasta ahora todo lo que has hecho en Go se parece a algo de PHP. Este módulo es distinto: aquí está lo que PHP no tiene. Empecemos por cómo trabaja PHP, que lo conoces bien.

Piensa en php-fpm como un restaurante con varios cocineros. Cada cocinero tiene su propia cocina, sus propios cazos y su propio libro de recetas. Llega un pedido (una petición), un cocinero lo prepara de principio a fin y, cuando acaba, lo tira todo y espera el siguiente. Los cocineros no se hablan ni comparten nada.

  • Cada worker de php-fpm es un proceso del sistema operativo con su propia memoria. Cuántos hay lo decide pm.max_children.
  • Dentro de un worker, tu script hace las cosas de una en una: si mandas 3 emails que tardan 1 segundo cada uno, la petición tarda 3 segundos.
  • Cuando la petición acaba, PHP borra todo: variables, conexiones, objetos. Lo que tiene que sobrevivir va a la BD, a Redis o a la sesión.

Y cuando en PHP quieres hacer varias cosas a la vez, tiras de herramientas sueltas:

Necesitas…En PHPEn Go
Varias peticiones HTTP a la vezcurl_multi_* o Guzzle con promesasUna goroutine por petición
Mandar 1.000 emails sin hacer esperar al usuarioUna cola (Redis, RabbitMQ) y un proceso worker aparteGoroutines en el mismo programa (o una cola, si quieres)
Alternar entre tareas a mediasFiber (PHP 8.1): se turnan, pero nunca corren a la vezGoroutines: se turnan y corren a la vez en varios núcleos
Atender muchas peticionesMás workers de php-fpm (más procesos, más memoria)Una goroutine por petición, dentro del mismo proceso

2 · La palabra go

Lanzar una goroutine es facilísimo: escribes go delante de una llamada a función. Esa función arranca a la vez que el resto y la línea siguiente se ejecuta sin esperarla. Es como decirle a un pinche «encárgate tú de esto» y seguir tú con lo tuyo.

Gomain.go
package main

import (
    "fmt"
    "time"
)

func avisar(titulo string) {
    fmt.Println("Recordatorio enviado:", titulo)
}

func main() {
    // Llamada normal: main espera a que avisar termine.
    avisar("Comprar pan")

    // Con go delante, avisar arranca en una goroutine y main sigue sin esperar.
    go avisar("Llamar al banco")

    // Truco SOLO para este ejemplo: dormir un poco para que la goroutine acabe.
    // En la sección siguiente verás la forma buena: sync.WaitGroup.
    time.Sleep(100 * time.Millisecond)
    fmt.Println("main termina")
}

También puedes lanzar una función anónima (una closure, del módulo 03), que es lo más habitual:

Gomain.go
// En PHP: (function () use ($titulo) { ... })(); pero aquí corre a la vez
go func() {
    fmt.Println("Guardando", titulo)
}()

¿Por qué? · En PHP no existe

¿Por qué goroutines y no procesos, como php-fpm? En PHP no existe

Un worker de php-fpm es un proceso entero del sistema operativo: arrancarlo es lento y cada uno ocupa decenas de megas de memoria. Por eso pm.max_children suele ser 10, 50 o 100, y si llegan más peticiones, esperan en la cola.

Una goroutine no es un proceso ni un hilo del sistema: es una tarea ligerísima que gestiona el propio programa de Go. Empieza ocupando unos 2 KB y crece solo si lo necesita. El planificador de Go (el scheduler, el jefe de cocina) reparte miles de goroutines entre unos pocos hilos del sistema, uno por núcleo.

  • Problema que resuelve: atender 10.000 conexiones a la vez sin 10.000 procesos ni gigas de RAM.
  • Fallo de PHP que evita: la petición que se queda esperando porque todos los workers están ocupados mandando emails o llamando a una API lenta.

3 · Esperar a que terminen: WaitGroup

sync.WaitGroup es un contador de goroutines pendientes. Imagina la libreta del jefe de cocina: apunta cada plato que encarga y lo tacha cuando se lo entregan. No cierra la cocina hasta que no queda nada apuntado.

  1. var wg sync.WaitGroup crea el contador, a cero. No hace falta new ni constructor.
  2. wg.Go(func() { ... }) (Go 1.25) apunta una tarea, la lanza en una goroutine y la tacha sola cuando termina.
  3. wg.Wait() se queda esperando hasta que el contador vuelve a cero.

Aquí tienes tres envíos de 1 segundo cada uno. En PHP, uno detrás de otro, tardarían 3 segundos; en Go tardan 1:

PHP 8.5avisos.php
<?php
declare(strict_types=1);

// Para hacer 3 peticiones a la vez, PHP necesita curl_multi
$urls = [
    "https://api.example.com/avisar/1",
    "https://api.example.com/avisar/2",
    "https://api.example.com/avisar/3",
];

$multi = curl_multi_init();
$handles = [];
foreach ($urls as $url) {
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_multi_add_handle($multi, $ch);
    $handles[] = $ch;
}

// El bucle que espera a que terminen todas (el wg.Wait() de PHP)
do {
    $estado = curl_multi_exec($multi, $activas);
    curl_multi_select($multi);
} while ($activas > 0 && $estado === CURLM_OK);

$respuestas = array_map(curl_multi_getcontent(...), $handles);
curl_multi_close($multi);

echo count($respuestas) . " avisos enviados" . PHP_EOL;
Gomain.go
package main

import (
    "fmt"
    "sync"
    "time"
)

// enviar simula mandar un aviso: tarda 1 segundo.
func enviar(titulo string) string {
    time.Sleep(time.Second)
    return "enviado: " + titulo
}

func main() {
    tareas := []string{"Comprar pan", "Llamar al banco", "Repasar Go"}
    // Un hueco por tarea: cada goroutine escribe SOLO en el suyo.
    resultados := make([]string, len(tareas))
    inicio := time.Now()

    var wg sync.WaitGroup
    for i, t := range tareas {
        // Sirve para cualquier función, no solo para HTTP
        wg.Go(func() {
            resultados[i] = enviar(t)
        })
    }
    // En PHP: el do/while con curl_multi_exec()
    wg.Wait()

    for _, r := range resultados {
        fmt.Println(r)
    }
    fmt.Printf("3 envíos de 1 s en %.0f s\n", time.Since(inicio).Seconds())
}

Fíjate en el truco de resultados[i]: cada goroutine escribe en su posición del slice. Nadie pisa a nadie y el resultado sale en el mismo orden que las tareas, termine antes la que termine.

4 · Concurrencia no es paralelismo

Dos palabras que se confunden mucho. Volvamos a la cocina:

  • Concurrencia: un cocinero con tres cazos al fuego. Remueve uno, pica algo para otro, vuelve al primero. Hay varias tareas en marcha a la vez, aunque solo haga una cosa en cada instante. Así funcionan las Fiber de PHP.
  • Paralelismo: tres cocineros, cada uno con su cazo. Hay varias cosas haciéndose en el mismo instante. Necesitas varios núcleos de CPU.

Las goroutines te dan las dos cosas: escribes el código como si cada tarea fuera independiente (concurrencia) y Go las reparte entre todos los núcleos de la máquina (paralelismo). Cuántos núcleos usa lo dice runtime.GOMAXPROCS(0), que por defecto vale el número de CPU.

Gomain.go
package main

import (
    "fmt"
    "runtime"
    "sync"
)

// minutosDe calcula los minutos estimados de un bloque de tareas.
func minutosDe(bloque []int) int {
    total := 0
    for _, m := range bloque {
        total += m
    }
    return total
}

func main() {
    fmt.Println("Núcleos que usa Go:", runtime.GOMAXPROCS(0))

    bloques := [][]int{{30, 15}, {60, 5}, {10, 10, 10}}
    parciales := make([]int, len(bloques))

    var wg sync.WaitGroup
    for i, bloque := range bloques {
        wg.Go(func() {
            parciales[i] = minutosDe(bloque)
        })
    }
    wg.Wait()

    // Los parciales se suman al final, cuando ya han terminado todas.
    total := 0
    for _, p := range parciales {
        total += p
    }
    fmt.Println("Parciales:", parciales, "Total:", total)
}

El orden en que terminan las goroutines lo decide el planificador y puede cambiar en cada ejecución. Por eso:

  1. No imprimas desde varias goroutines si te importa el orden: guarda los resultados y pinta al final.
  2. Si necesitas un orden, usa un índice (resultados[i]) o ordena al final con slices.Sort.
  3. Si solo necesitas un total, súmalo cuando todas hayan terminado.

5 · Goroutines en tu servidor web

Ya las has usado sin saberlo. En el módulo 07, http.ListenAndServe lanza una goroutine por cada petición. Tu handler se ejecuta en muchas goroutines a la vez dentro del mismo proceso.

La pregunta que te vas a hacer

«Vale, pero… ¿y qué cambia eso para mi API?»

En PHP, dos peticiones nunca ven las variables de la otra: cada una vive en su proceso. En Go, si tu handler guarda las tareas en un map que es variable del paquete, todas las peticiones lo comparten. Eso es estupendo (una caché en memoria sin Redis) y peligroso (dos goroutines escribiendo a la vez). Lo arreglarás con sync.Mutex dos lecciones más adelante.

Y lo que en PHP mandas a una cola para no hacer esperar al usuario (emails, miniaturas, avisos), en Go muchas veces basta con una goroutine. Si el trabajo tiene que sobrevivir a un reinicio del servidor, sigue usando una cola de verdad.

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Tres cocineros

El programa tiene 3 tareas y un slice hechas con un bool por tarea. Dentro del for, lanza con wg.Go una goroutine por tarea que marque hechas[i] = true. El wg.Wait() ya está puesto. Debe imprimir Hechas: 3 de 3.

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. PHP: un proceso por petición y sin compartir nada. Go: un programa con miles de goroutines (en PHP, más workers de php-fpm).
  2. go f() lanza f a la vez y sigue sin esperar (en PHP, lo más cercano es curl_multi o una cola).
  3. Si main() termina, mueren todas las goroutines: espéralas con sync.WaitGroup (en PHP, el bucle de curl_multi_exec()).
  4. wg.Go(func() { ... }) lanza y apunta; wg.Wait() espera a todas.
  5. Las goroutines terminan en cualquier orden: cada una escribe en su hueco (resultados[i]) y se pinta al final (en PHP, como un array_map()).

Para recordarlo: «Lanza, Apunta, Espera»

LLanza
go f()
AApunta
wg.Go(...)
EEspera
wg.Wait()

Como el jefe de cocina: Lanza el plato a un cocinero, lo Apunta en la libreta y Espera a que la libreta quede vacía antes de cerrar. Si cierra antes (main() termina), los platos a medias se tiran.