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

context: cancelar y poner timeouts

9 min de lectura 3 retos

Con goroutines por todas partes hace falta una forma de decirles «para, ya no hace falta» o «tienes medio segundo». Eso es context: un aviso de cancelación y un tiempo máximo que viajan de función en función. En PHP lo más parecido es max_execution_time, pero ese mata la petición entera.

¿De dónde vienen los nombres?

ctx = Abreviatura de context (contexto)
El nombre que todo el mundo da al parámetro de tipo context.Context. En PHP no hay un objeto así: el «contexto» de la petición son variables globales como $_SERVER.
Background = background (fondo)
El contexto raíz, vacío: el que está «de fondo» cuando aún no hay petición. Se usa en main() y en los tests.
Deadline = deadline (fecha límite)
El momento a partir del cual ya no vale la pena seguir. Su error es context.DeadlineExceeded (exceeded, superada). En PHP, el Maximum execution time exceeded de max_execution_time.
Done = done (hecho, terminado)
Un canal que se cierra cuando el contexto se cancela o caduca. Se escucha en un select, como el resto de canales.
En 4 ideas
1/4

context.Context lleva un aviso de cancelación y, si quieres, un tiempo máximo. Se pasa como primer parámetro, ctx, a todo lo que pueda tardar. En PHP, cada cosa tiene su timeout suelto (max_execution_time, CURLOPT_TIMEOUT).

1 · Para qué sirve context

Pides una pizza a domicilio y a los cinco minutos llamas para cancelarla. En una pizzería bien organizada, el aviso llega a todos: el que amasa para, el del horno no la mete y el repartidor no sale. En una mal organizada, la pizza se hace igual y se tira. context es ese aviso que llega a toda la cadena.

En Go una petición puede repartir el trabajo en muchas goroutines: una consulta a la BD, dos llamadas a APIs, un cálculo. Si el usuario cierra la pestaña o se pasa el tiempo máximo, hay que avisar a todas para que paren y no gasten CPU ni conexiones para nadie.

SituaciónEn PHPEn Go
La petición tarda demasiadomax_execution_time mata el script enterocontext.WithTimeout: cada función para de forma ordenada
Una API externa tardaCURLOPT_TIMEOUT (solo para esa llamada)El mismo ctx para la API, la BD y lo que haga falta
El usuario cierra la pestañaconnection_aborted() o ignore_user_abort()r.Context() se cancela solo
Parar un trabajo a mitadNo se puede: el proceso sigue o muerecancel() y quien escucha ctx.Done() para

¿Por qué? · En PHP no existe

¿Por qué hay que pasar ctx a mano a cada función? En PHP no existe

En PHP la petición es el proceso entero: si se acaba el tiempo, PHP mata el proceso y con él todo lo que estaba haciendo. No hace falta avisar a nadie porque no queda nadie.

En Go el programa sigue vivo y atiende miles de peticiones a la vez. No puede matarse entero porque una petición tarde. Así que cada petición lleva su propio ctx y se lo pasa a cada función que llama, como quien pasa el número de pedido a cada cocinero.

  • Problema que resuelve: cancelar el trabajo de una petición sin tocar las demás.
  • Fallo de PHP que evita: el script que muere a mitad de escribir en la BD por max_execution_time, sin finally ni limpieza.
  • Por qué no una variable global: varias peticiones a la vez tendrían que compartirla. Al ser un parámetro, se ve a simple vista qué funciones se pueden cancelar.

2 · WithCancel: parar cuando tú digas

context.WithCancel(padre) te devuelve dos cosas: el ctx hijo, que repartes, y la función cancel, que guardas tú. Cuando llamas a cancel(), el canal ctx.Done() se cierra y todos los que lo escuchan se enteran a la vez.

Gomain.go
package main

import (
    "context"
    "fmt"
)

// generarRecordatorios crea recordatorios sin fin hasta que le dicen que pare.
func generarRecordatorios(ctx context.Context) <-chan string {
    salida := make(chan string)
    go func() {
        defer close(salida)
        for n := 1; ; n++ {
            select {
            case salida <- fmt.Sprintf("Recordatorio %d", n):
            case <-ctx.Done():
                fmt.Println("Generador parado:", ctx.Err())
                return
            }
        }
    }()
    return salida
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    recordatorios := generarRecordatorios(ctx)

    for range 3 {
        fmt.Println(<-recordatorios)
    }
    // Ya tenemos bastantes: avisamos al generador.
    cancel()

    // Esperamos a que el generador cierre su canal.
    for range recordatorios {
    }
    fmt.Println("Fin")
}

Sin el ctx, esa goroutine se quedaría para siempre intentando enviar el recordatorio 4: una fuga de goroutine. Con él, termina limpia.

3 · WithTimeout: un tiempo máximo

context.WithTimeout(padre, d) es un WithCancel con alarma: se cancela solo cuando pasa d. Es el CURLOPT_TIMEOUT de PHP, pero vale para cualquier cosa que acepte un ctx:

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

// Cada herramienta de PHP trae su propio timeout, y cada uno se pone en un sitio.
set_time_limit(5);

$ch = curl_init("https://api.example.com/tareas");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT_MS => 500,
]);
$respuesta = curl_exec($ch);

if ($respuesta === false && curl_errno($ch) === CURLE_OPERATION_TIMEDOUT) {
    echo "La consulta tardó demasiado" . PHP_EOL;
    exit(1);
}

$tareas = json_decode($respuesta, true, flags: JSON_THROW_ON_ERROR);
echo count($tareas) . " tareas" . PHP_EOL;
Gomain.go
package main

import (
    "context"
    "errors"
    "fmt"
    "time"
)

// buscarTareas simula una consulta que tarda 2 segundos y respeta el ctx.
func buscarTareas(ctx context.Context) ([]string, error) {
    select {
    case <-time.After(2 * time.Second):
        return []string{"Comprar pan", "Repasar Go"}, nil
    case <-ctx.Done():
        return nil, ctx.Err()
    }
}

func main() {
    // En PHP: curl_setopt($ch, CURLOPT_TIMEOUT_MS, 500);
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    // Libera el temporizador aunque todo vaya bien.
    defer cancel()

    tareas, err := buscarTareas(ctx)
    // En PHP: curl_errno($ch) === CURLE_OPERATION_TIMEDOUT
    if errors.Is(err, context.DeadlineExceeded) {
        fmt.Println("La consulta tardó demasiado:", err)
        return
    }
    fmt.Println(len(tareas), "tareas")
}

Cuando un contexto termina, ctx.Err() dice por qué. Compáralo con errors.Is, como cualquier error del módulo 06:

ctx.Err()CuándoTexto del error
nilSigue vivo—
context.CanceledAlguien llamó a cancel()context canceled
context.DeadlineExceededPasó el tiempo de WithTimeout o WithDeadlinecontext deadline exceeded

4 · context en tu API

En el servidor del módulo 07 no tienes que crear el contexto: cada petición trae el suyo en r.Context(), y net/http lo cancela solo cuando el cliente cierra la conexión. Pásalo a todo lo que hagas dentro del handler.

Gomain.go
package main

import (
    "context"
    "fmt"
    "net/http"
    "net/http/httptest"
    "strings"
    "time"
)

func listarTareas(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    select {
    // La consulta simulada tarda 100 ms.
    case <-time.After(100 * time.Millisecond):
        fmt.Fprintln(w, "3 tareas")
    case <-ctx.Done():
        // El cliente se ha ido: no seguimos trabajando para nadie.
        http.Error(w, "petición cancelada", http.StatusServiceUnavailable)
    }
}

func main() {
    // 1. Una petición normal.
    rec := httptest.NewRecorder()
    req := httptest.NewRequest(http.MethodGet, "/tareas", nil)
    listarTareas(rec, req)
    fmt.Println(rec.Code, strings.TrimSpace(rec.Body.String()))

    // 2. Un cliente que se cansa a los 10 ms.
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
    defer cancel()
    rec = httptest.NewRecorder()
    req = httptest.NewRequest(http.MethodGet, "/tareas", nil).WithContext(ctx)
    listarTareas(rec, req)
    fmt.Println(rec.Code, strings.TrimSpace(rec.Body.String()))
}

Con una BD de verdad (lo harás en el proyecto final) se usan las versiones ...Context de cada método: db.QueryContext(ctx, ...), db.ExecContext(ctx, ...). Si el cliente se va, la consulta se cancela en la propia base de datos.

La pregunta que te vas a hacer

«Vale, pero… ¿dónde está el max_execution_time de Go?»

No hay uno global que mate el programa, porque matar el programa tumbaría todas las peticiones. En su lugar tienes tres piezas:

  1. Los tiempos del servidor: http.Server{ReadTimeout: …, WriteTimeout: …}, para clientes lentos o colgados.
  2. http.TimeoutHandler(handler, 5*time.Second, "tardó demasiado"), que pone un tiempo máximo a cada petición y cancela su r.Context().
  3. context.WithTimeout dentro del handler para una parte concreta (la llamada a una API lenta).

5 · Las reglas de context

  1. Primer parámetro y llamado ctx: func Buscar(ctx context.Context, id int) (Tarea, error). Todo el mundo lo escribe igual.
  2. No lo guardes en un struct: pásalo en cada llamada. Un repositorio vive mucho; una petición, poco.
  3. Siempre defer cancel() justo después de WithCancel o WithTimeout, aunque todo vaya bien: libera el temporizador.
  4. context.Background() solo en main(), en los tests o al arrancar. Dentro de un handler, r.Context().
  5. Quien hace algo lento escucha ctx.Done() (en un select) o pasa el ctx a quien lo escuche.
  6. context.WithValue solo para datos de la petición que cruzan capas (el ID de la petición para los logs), nunca para pasar parámetros normales.

Si te olvidas del cancel, go vet te avisa:

Gomain.go
// MAL: tiramos la función cancel con _.
ctx, _ := context.WithTimeout(context.Background(), time.Second)
$ go vet .
main.go:10:10: the cancel function returned by context.WithTimeout should be called, not discarded, to avoid a context leak

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

Para cuando te lo pidan

Procesar(ctx context.Context, tareas []string, hacer func(string)) int llama a hacer con cada tarea y devuelve cuántas ha hecho, pero ignora el ctx. Haz que, antes de cada tarea, mire si el contexto se ha cancelado (ctx.Err() != nil) y, si es así, pare y devuelva las que lleva. En PHP sería comprobar connection_aborted() en cada vuelta del foreach.

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. ctx context.Context como primer parámetro de todo lo que pueda tardar (en PHP, cada cosa con su timeout suelto).
  2. WithCancel para parar cuando digas; WithTimeout para parar solo; siempre defer cancel() (en PHP, el finally que libera).
  3. Quien trabaja escucha <-ctx.Done() en un select y devuelve ctx.Err() (en PHP, connection_aborted() a mano).
  4. errors.Is(err, context.DeadlineExceeded) = se acabó el tiempo (en PHP, CURLE_OPERATION_TIMEDOUT).
  5. En un handler, r.Context() se cancela cuando el cliente se va; pásalo a la BD con QueryContext (en PHP, ignore_user_abort()).

Para recordarlo: «Pasa, Escucha, Cancela»

PPasa
func f(ctx context.Context, ...)
EEscucha
case <-ctx.Done():
CCancela
defer cancel()

El número de pedido de la pizzería: se Pasa a cada cocinero, cada uno Escucha si el cliente ha llamado para anular y quien hizo el pedido siempre Cancela al terminar, aunque haya ido bien.