Lección 28 de 36 · Concurrencia: lo que PHP no tiene✦ WebMCP implementado
Canales y select
10 min de lectura4 retos
Las goroutines necesitan pasarse datos sin pisarse. Go les da canales: tubos por los que una goroutine mete un valor y otra lo saca. En esta lección los creas, los cierras, los recorres con range y eliges entre varios a la vez con select.
¿De dónde vienen los nombres?
chan = channel (canal)
El tipo de los canales: chan string es un canal por el que pasan strings. En PHP lo más parecido es una cola de Redis (lPush / brPop), pero dentro del mismo programa y sin servidor aparte.
<- = Una flecha
Indica hacia dónde va el dato: ch <- v mete v en el canal y v := <-ch lo saca. PHP no tiene ningún operador así.
select = select (seleccionar)
Espera a varios canales y elige el primero que esté listo. Lo más cercano en PHP es stream_select(), que espera a varios sockets.
CSP = Communicating Sequential Processes (procesos secuenciales que se comunican)
La teoría de Tony Hoare (1978) en la que se inspiran los canales de Go: tareas independientes que se pasan mensajes en vez de compartir variables.
En 4 ideas
1/4
Un canal es un tubo con tipo: ch := make(chan string). ch <- "pan" envía y t := <-ch recibe. En PHP lo más parecido es una cola de Redis con lPush y brPop.
Un canal sin buffer obliga a que el que envía y el que recibe se encuentren: el primero que llega espera al otro. Con buffer (make(chan string, 10)) es una bandeja con 10 huecos: solo se espera si está llena o vacía.
close(ch) avisa de que no llegarán más valores y for t := range ch lee hasta ese cierre. Es el while (($t = array_shift($cola)) !== null) de PHP, pero esperando a que lleguen.
select espera a varios canales a la vez y atiende al primero que esté listo; con time.After pones un tiempo máximo y con default no esperas nada. PHP no tiene nada igual fuera de stream_select().
1 · Qué es un canal
Imagina la ventanilla entre la cocina y la sala de un restaurante. El cocinero deja el plato y el camarero lo recoge. Ninguno entra en el terreno del otro: solo se pasan platos por la ventanilla. Eso es un canal.
Gomain.go
package main
import"fmt"funcmain() {
// Un canal de strings: la ventanilla por la que pasan los avisos.
avisos := make(chanstring)
gofunc() {
// Flecha HACIA el canal: enviar.
avisos <- "Tarea «Comprar pan» creada"
}()
// Flecha DESDE el canal: recibir. main espera aquí hasta que llegue algo.
mensaje := <-avisos
fmt.Println(mensaje)
}
Operación
Qué hace
En PHP (cola de Redis)
ch := make(chan string)
Crea un canal de strings
Elegir el nombre de la lista: "tareas"
ch <- t
Envía t (espera si nadie recibe)
$redis->lPush("tareas", $t)
t := <-ch
Recibe un valor (espera si no hay)
$redis->brPop(["tareas"], 0)
close(ch)
Avisa: no se enviará nada más
No existe: la cola nunca «se acaba»
Fíjate en que ya no hace falta WaitGroup ni time.Sleep: <-avisosespera hasta que llega el valor. Recibir de un canal es también una forma de sincronizar.
¿Por qué? · En PHP no existe
¿Por qué canales y no variables compartidas? En PHP no existe
En PHP nunca compartes variables entre peticiones: cada una tiene su proceso. Cuando dos procesos tienen que hablar, usan algo de fuera (Redis, la BD, una cola). Funciona, pero hace falta otro servidor y todo pasa por la red.
En Go las goroutines viven en el mismo programa y podrían tocar las mismas variables, pero si dos lo hacen a la vez se pisan (una carrera de datos). Los canales resuelven eso: el dato pasa de mano en mano y en cada momento solo lo tiene una goroutine. El lema de Go lo resume así: «No te comuniques compartiendo memoria; comparte memoria comunicándote».
Problema que resuelve: pasar trabajo y resultados entre goroutines sin que se pisen.
Fallo de PHP que evita: montar Redis o RabbitMQ solo para que dos partes del mismo programa se pasen datos.
2 · Canales con buffer
El canal de antes no tiene buffer (búfer, una zona de espera): es una entrega en mano. Si el cocinero llega con el plato y no hay camarero, se queda quieto esperando. Si le das un número a make, el canal tiene una bandeja con ese número de huecos: el cocinero deja el plato y sigue, salvo que la bandeja esté llena.
Gomain.go
package main
import"fmt"funcmain() {
// Bandeja con 2 huecos.
bandeja := make(chanstring, 2)
// Caben dos sin que nadie las recoja.
bandeja <- "Comprar pan"
bandeja <- "Repasar Go"// len: cuántas hay ahora; cap: cuántas caben (capacity).
fmt.Println("En la bandeja:", len(bandeja), "de", cap(bandeja))
// Un tercer envío aquí se quedaría esperando para siempre: está llena.
fmt.Println(<-bandeja)
fmt.Println(<-bandeja)
}
Canal
Enviar espera si…
Recibir espera si…
make(chan T) (sin buffer)
Nadie está recibiendo
Nadie está enviando
make(chan T, n) (con buffer)
Ya hay n valores dentro
Está vacío
3 · Cerrar un canal y recorrerlo con range
Cuando el que envía ya no tiene nada más, llama a close(ch). Es como colgar el cartel de «cocina cerrada»: el camarero recoge los platos que queden y sabe que no vendrán más. for t := range ch hace justo eso: lee hasta que el canal está cerrado y vacío.
Con esto montas el patrón más típico: un trabajador que procesa lo que le llega por una cola. En PHP necesitas dos scripts y Redis; en Go, una goroutine:
PHP 8.5trabajador.php
<?phpdeclare(strict_types=1);
// productor.php: lo ejecuta una petición web$redis = newRedis();
$redis->connect("127.0.0.1");
$redis->lPush("tareas", json_encode(["titulo" => "Comprar pan"]));
$redis->lPush("tareas", json_encode(["titulo" => "Repasar Go"]));
// trabajador.php: OTRO proceso (php trabajador.php) que espera tareaswhile (true) {
// brPop espera hasta que llega algo, como <-canal en Go
[, $json] = $redis->brPop(["tareas"], 0);
$tarea = json_decode($json, true);
echo"Procesando: " . $tarea["titulo"] . PHP_EOL;
}
Gomain.go
package main
import"fmt"typeTareastruct {
Titulostring
}
// chan<- solo puede enviar; <-chan solo puede recibir.functrabajador(cola <-chanTarea, fin chan<- bool) {
// En PHP: while (true) { $redis->brPop(...) }for t := range cola {
fmt.Println("Procesando:", t.Titulo)
}
// range termina cuando la cola está cerrada y vacía.
fin <- true
}
funcmain() {
cola := make(chanTarea, 10)
fin := make(chanbool)
gotrabajador(cola, fin)
// En PHP: $redis->lPush("tareas", ...)
cola <- Tarea{Titulo: "Comprar pan"}
cola <- Tarea{Titulo: "Repasar Go"}
close(cola)
// Esperamos a que el trabajador acabe.
<-fin
}
Si quieres saber si un canal está cerrado al recibir, usa el comma ok del módulo 04: t, ok := <-cola. Si ok es false, el canal está cerrado y vacío, y t trae el valor cero.
Y si un trabajador no da abasto, pones varios leyendo de la misma cola: es un pool de trabajadores (worker pool), lo mismo que arrancar varios php trabajador.php. Aquí tres trabajadores se reparten seis tareas y mandan los minutos por otro canal:
Gomain.go
package main
import (
"fmt""sync"
)
funcmain() {
minutos := []int{30, 15, 60, 5, 10, 20}
cola := make(chanint)
hechos := make(chanint, len(minutos))
var wg sync.WaitGroupforrange3 {
wg.Go(func() {
for m := range cola {
hechos <- m
}
})
}
for _, m := range minutos {
cola <- m
}
close(cola)
// Cuando acaban los tres trabajadores, ya no llegará nada más a hechos.
wg.Wait()
close(hechos)
total := 0for m := range hechos {
total += m
}
fmt.Println("Minutos de trabajo hechos:", total)
}
4 · select: atender al primero que llegue
A veces una goroutine espera a varias cosas: una tarea nueva, un aviso de parar o que pase el tiempo máximo. select es como un camarero pendiente de varias ventanillas: atiende la primera en la que aparezca un plato.
Gomain.go
package main
import (
"fmt""time"
)
// buscarTarea simula una consulta lenta: tarda lo que le digas.funcbuscarTarea(tarda time.Duration) <-chanstring {
resultado := make(chanstring, 1)
gofunc() {
time.Sleep(tarda)
resultado <- "Comprar pan"
}()
return resultado
}
funcmain() {
// 1. Gana la consulta: llega antes de 1 segundo.select {
case t := <-buscarTarea(10 * time.Millisecond):
fmt.Println("Encontrada:", t)
case <-time.After(time.Second):
fmt.Println("Se acabó el tiempo")
}
// 2. Gana el reloj: la consulta tarda 2 segundos y solo esperamos 1.select {
case t := <-buscarTarea(2 * time.Second):
fmt.Println("Encontrada:", t)
case <-time.After(time.Second):
fmt.Println("Se acabó el tiempo")
}
// 3. Con default no se espera nada: si no hay nada listo, entra en default.
vacia := make(chanstring)
select {
case t := <-vacia:
fmt.Println("Había algo:", t)
default:
fmt.Println("No hay nada, sigo con lo mío")
}
}
Cada case es una operación con un canal: recibir (t := <-ch) o enviar (ch <- t).
Si varios están listos a la vez, select elige uno al azar: no cuentes con el orden.
time.After(d) devuelve un canal que recibe un valor cuando pasa d: es tu tiempo máximo.
default se ejecuta si ningún case está listo ya. Sin default, select espera.
¿Por qué? · En PHP no existe
¿Por qué select? En PHP no existe
En PHP, cuando llamas a algo lento (file_get_contents() de una API, una consulta pesada), el script se queda parado ahí. Para no esperar eternamente, cada función tiene su propio timeout: CURLOPT_TIMEOUT, default_socket_timeout, max_execution_time… cada uno se configura en un sitio distinto.
select junta todo en una sola herramienta: esperas a la vez al resultado, al reloj y a quien te pida parar, y sigues por el primero que llegue. Funciona igual para una API, una consulta o un cálculo, porque todo son canales. Su hermano mayor, context, lo verás en la última lección.
5 · Errores típicos con canales
Los canales esperan, y esa espera puede ser para siempre. Si enviamos por un canal sin buffer en main y nadie recibe, Go detecta que todas las goroutines están dormidas y para el programa:
Gomain.go
tareas := make(chanstring)
// Nadie recibe: main se queda esperando para siempre.
tareas <- "Comprar pan"
fmt.Println(<-tareas)
$ go run main.go
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/m/main.go:7 +0x38
exit status 2
Ese deadlock (bloqueo mutuo: todos esperan a alguien que nunca llega) es como un cocinero que no suelta el plato hasta que venga el camarero… y el camarero es él mismo. Y enviar por un canal ya cerrado no espera: revienta.
$ go run main.go
panic: send on closed channel
goroutine 1 [running]:
main.main()
/m/main.go:6 +0x40
exit status 2
Situación
Qué pasa
Enviar sin nadie que reciba (sin buffer)
Espera para siempre; si es todo el programa, deadlock!
Recibir de un canal vacío que nadie cierra
Espera para siempre (tu range no termina)
Enviar a un canal cerrado
panic: send on closed channel
Recibir de un canal cerrado
No espera: devuelve el valor cero y ok == false
Cerrar dos veces
panic: close of closed channel
La pregunta que te vas a hacer
«Vale, pero… ¿entonces ya no necesito Redis ni RabbitMQ?»
Para pasar trabajo dentro del mismo programa, no: un canal y unas goroutines hacen de cola y de trabajadores. Pero un canal vive en memoria: si el servidor se reinicia, lo que estaba dentro se pierde, y otro servidor no lo ve. Si las tareas tienen que sobrevivir a un reinicio o repartirse entre varias máquinas, sigue usando una cola de verdad.
Una goroutine manda tres títulos por el canal avisos y luego lo cierra, pero main solo recibe uno. Cambia main para que imprima los tres, uno por línea, recorriendo el canal con range. Es el while de un worker de PHP que vacía una cola.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Cambia la última línea por for aviso := range avisos { fmt.Println(aviso) }. El bucle termina solo cuando la goroutine cierra el canal.
Reto 2 de 4 · ✓ Resuelto
Cuenta las hechas
Completa ContarHechas(estados <-chan bool) int: lee del canal hasta que esté cerrado y devuelve cuántos valores eran true. Por ejemplo, si llegan true, false, true y se cierra, devuelve 2. Es un count(array_filter($estados)) de PHP, pero leyendo de un canal.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Un for hecha := range estados { if hecha { hechas++ } }. El range sale solo cuando el canal está cerrado y vacío.
Reto 3 de 4 · ✓ Resuelto
Una cadena de montaje
Monta una cadena de dos piezas unidas por canales (un pipeline). Generar(titulos []string) <-chan string ya está hecha: manda cada título por un canal y lo cierra. Completa EnMayusculas(entrada <-chan string) <-chan string para que lance una goroutine que lea cada título, lo mande en mayúsculas (strings.ToUpper) por un canal nuevo y lo cierre al terminar. Es un array_map('strtoupper', $titulos) de PHP, pero cada pieza trabaja a la vez que la anterior.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. La estructura ya está bien (goroutine, range de la entrada y close al final). Solo envía el título transformado con la función correcta del paquete strings.
Reto 4 de 4 · ✓ Resuelto
Espera, pero no para siempre
Completa RecibirConLimite(trabajo <-chan string, limite time.Duration) (string, bool): si llega un título por trabajo antes de que pase limite, devuélvelo con true; si no, devuelve "" y false. Ahora usa select con default, que no espera nada, y por eso pierde los títulos que llegan un poco tarde. Cambia el default por un case con time.After(limite). En PHP sería el CURLOPT_TIMEOUT de una petición.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.default entra si no hay nada listo en ese instante. case <-time.After(limite): en su lugar hace que select espere al título o al reloj, lo que llegue antes.
Resumen
Lo que te llevas de esta lección
ch := make(chan T), ch <- v envía y v := <-ch recibe (en PHP, lPush y brPop de Redis).
Sin buffer, el que envía y el que recibe se esperan; con buffer (make(chan T, n)) hay una bandeja de n huecos.
close(ch) lo hace quien envía, y for v := range ch lee hasta el cierre (en PHP, el while (true) del worker).
select atiende al primer canal listo; time.After pone un tiempo máximo y default no espera (en PHP, cada función con su timeout).
Un canal que nadie atiende bloquea para siempre: deadlock! si es todo el programa, o una goroutine perdida si no.
Para recordarlo: «La flecha dice adónde va el plato»
ch <- plato: el plato entra en la ventanilla. plato := <-ch: el plato sale de la ventanilla. Y quien cocina es quien cuelga el cartel de cerrado (close).