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 lectura3 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.
Poner go delante de una llamada la lanza en una goroutine y el programa sigue sin esperar. En PHP no hay nada así dentro de un script: lo más cercano es curl_multi (solo para HTTP) o mandar el trabajo a una cola.
Cuando main() termina, todas las goroutines mueren con ella. Para esperarlas se usa sync.WaitGroup y su método wg.Go(...), el equivalente al bucle que espera en curl_multi_exec().
Las goroutines no terminan en orden. Cada una guarda su resultado en su propio hueco (resultados[i]) y así el resultado final sale siempre igual, como un array_map() que se hace a la vez.
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 PHP
En Go
Varias peticiones HTTP a la vez
curl_multi_* o Guzzle con promesas
Una goroutine por petición
Mandar 1.000 emails sin hacer esperar al usuario
Una cola (Redis, RabbitMQ) y un proceso worker aparte
Goroutines en el mismo programa (o una cola, si quieres)
Alternar entre tareas a medias
Fiber (PHP 8.1): se turnan, pero nunca corren a la vez
Goroutines: se turnan y corren a la vez en varios núcleos
Atender muchas peticiones
Má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"
)
funcavisar(titulo string) {
fmt.Println("Recordatorio enviado:", titulo)
}
funcmain() {
// Llamada normal: main espera a que avisar termine.avisar("Comprar pan")
// Con go delante, avisar arranca en una goroutine y main sigue sin esperar.goavisar("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 vezgofunc() {
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.
var wg sync.WaitGroup crea el contador, a cero. No hace falta new ni constructor.
wg.Go(func() { ... }) (Go 1.25) apunta una tarea, la lanza en una goroutine y la tacha sola cuando termina.
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
<?phpdeclare(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 ($urlsas$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);
echocount($respuestas) . " avisos enviados" . PHP_EOL;
Gomain.go
package main
import (
"fmt""sync""time"
)
// enviar simula mandar un aviso: tarda 1 segundo.funcenviar(titulo string) string {
time.Sleep(time.Second)
return"enviado: " + titulo
}
funcmain() {
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.WaitGroupfor 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.funcminutosDe(bloque []int) int {
total := 0for _, m := range bloque {
total += m
}
return total
}
funcmain() {
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.WaitGroupfor 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 := 0for _, 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:
No imprimas desde varias goroutines si te importa el orden: guarda los resultados y pinta al final.
Si necesitas un orden, usa un índice (resultados[i]) o ordena al final con slices.Sort.
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.
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
Pista. Escribe wg.Go(func() { hechas[i] = true }) dentro del for y borra el _ = i.
Reto 2 de 3 · ✓ Resuelto
Recordatorios a la vez
enviar tarda 100 ms. EnviarRecordatorios(tareas []string) []string las manda una detrás de otra, así que con 5 tareas tarda medio segundo. Haz que las mande todas a la vez (una goroutine por tarea) y que devuelva los resultados en el mismo orden que las tareas. Con 5 tareas debe tardar menos de 300 ms. Es lo que en PHP harías con curl_multi.
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, mete el cuerpo del for en un wg.Go(func() { ... }) y llama a wg.Wait() antes del return. Cada goroutine escribe en resultados[i], así el orden se mantiene.
Reto 3 de 3 · ✓ Resuelto
Minutos totales en paralelo
Tienes las estimaciones (en minutos) de las tareas repartidas en bloques: [][]int{{30, 15}, {60}, {10, 10, 10}}. Completa MinutosTotales(bloques [][]int) int para que sume cada bloque en su propia goroutine, guarde cada suma en un slice de parciales y, cuando hayan terminado todas, devuelva el total (135 en el ejemplo). Es un array_sum(array_map('array_sum', $bloques)) de PHP, pero repartido entre cocineros.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Igual que el ejemplo de la sección «Concurrencia no es paralelismo»: un parciales[i] = sumar(bloque) dentro de wg.Go, wg.Wait() y después un for que sume los parciales. No sumes directamente en una variable compartida desde las goroutines: eso es una carrera de datos.
Resumen
Lo que te llevas de esta lección
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).
go f() lanza f a la vez y sigue sin esperar (en PHP, lo más cercano es curl_multi o una cola).
Si main() termina, mueren todas las goroutines: espéralas con sync.WaitGroup (en PHP, el bucle de curl_multi_exec()).
wg.Go(func() { ... }) lanza y apunta; wg.Wait() espera a todas.
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.