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

Canales y select

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

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"

func main() {
    // Un canal de strings: la ventanilla por la que pasan los avisos.
    avisos := make(chan string)

    go func() {
        // 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ónQué haceEn PHP (cola de Redis)
ch := make(chan string)Crea un canal de stringsElegir el nombre de la lista: "tareas"
ch <- tEnvía t (espera si nadie recibe)$redis->lPush("tareas", $t)
t := <-chRecibe un valor (espera si no hay)$redis->brPop(["tareas"], 0)
close(ch)Avisa: no se enviará nada másNo existe: la cola nunca «se acaba»

Fíjate en que ya no hace falta WaitGroup ni time.Sleep: <-avisos espera 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"

func main() {
    // Bandeja con 2 huecos.
    bandeja := make(chan string, 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)
}
CanalEnviar espera si…Recibir espera si…
make(chan T) (sin buffer)Nadie está recibiendoNadie está enviando
make(chan T, n) (con buffer)Ya hay n valores dentroEstá 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
<?php
declare(strict_types=1);

// productor.php: lo ejecuta una petición web
$redis = new Redis();
$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 tareas
while (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"

type Tarea struct {
    Titulo string
}

// chan<- solo puede enviar; <-chan solo puede recibir.
func trabajador(cola <-chan Tarea, 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
}

func main() {
    cola := make(chan Tarea, 10)
    fin := make(chan bool)

    go trabajador(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"
)

func main() {
    minutos := []int{30, 15, 60, 5, 10, 20}
    cola := make(chan int)
    hechos := make(chan int, len(minutos))

    var wg sync.WaitGroup
    for range 3 {
        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 := 0
    for 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.
func buscarTarea(tarda time.Duration) <-chan string {
    resultado := make(chan string, 1)
    go func() {
        time.Sleep(tarda)
        resultado <- "Comprar pan"
    }()
    return resultado
}

func main() {
    // 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(chan string)
    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(chan string)
// 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ónQué 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 cierraEspera para siempre (tu range no termina)
Enviar a un canal cerradopanic: send on closed channel
Recibir de un canal cerradoNo espera: devuelve el valor cero y ok == false
Cerrar dos vecespanic: 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.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Recoge todos los avisos

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

Resumen

Lo que te llevas de esta lección

  1. ch := make(chan T), ch <- v envía y v := <-ch recibe (en PHP, lPush y brPop de Redis).
  2. Sin buffer, el que envía y el que recibe se esperan; con buffer (make(chan T, n)) hay una bandeja de n huecos.
  3. close(ch) lo hace quien envía, y for v := range ch lee hasta el cierre (en PHP, el while (true) del worker).
  4. 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).
  5. 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).