Lección 30 de 36 · Concurrencia: lo que PHP no tiene✦ WebMCP implementado
context: cancelar y poner timeouts
9 min de lectura3 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).
ctx, cancel := context.WithCancel(padre) crea un contexto que cancelas tú con cancel(); context.WithTimeout(padre, 2*time.Second) se cancela solo. Siempre defer cancel(), como el finally que cierra un recurso en PHP.
Quien trabaja escucha <-ctx.Done() en un select y, si llega, para y devuelve ctx.Err(): context.Canceled o context.DeadlineExceeded. En PHP, comprobar connection_aborted() a mano.
En un servidor, r.Context() se cancela solo cuando el cliente se va. Pásalo a la BD y a las APIs y no trabajarás para nadie. En PHP, con ignore_user_abort(false), el script muere a la fuerza en vez de parar de forma ordenada.
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ón
En PHP
En Go
La petición tarda demasiado
max_execution_time mata el script entero
context.WithTimeout: cada función para de forma ordenada
Una API externa tarda
CURLOPT_TIMEOUT (solo para esa llamada)
El mismo ctx para la API, la BD y lo que haga falta
El usuario cierra la pestaña
connection_aborted() o ignore_user_abort()
r.Context() se cancela solo
Parar un trabajo a mitad
No se puede: el proceso sigue o muere
cancel() 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.funcgenerarRecordatorios(ctx context.Context) <-chanstring {
salida := make(chanstring)
gofunc() {
deferclose(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
}
funcmain() {
ctx, cancel := context.WithCancel(context.Background())
recordatorios := generarRecordatorios(ctx)
forrange3 {
fmt.Println(<-recordatorios)
}
// Ya tenemos bastantes: avisamos al generador.cancel()
// Esperamos a que el generador cierre su canal.forrange 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
<?phpdeclare(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);
echocount($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.funcbuscarTareas(ctx context.Context) ([]string, error) {
select {
case <-time.After(2 * time.Second):
return []string{"Comprar pan", "Repasar Go"}, nilcase <-ctx.Done():
returnnil, ctx.Err()
}
}
funcmain() {
// 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.defercancel()
tareas, err := buscarTareas(ctx)
// En PHP: curl_errno($ch) === CURLE_OPERATION_TIMEDOUTif 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ándo
Texto del error
nil
Sigue vivo
—
context.Canceled
Alguien llamó a cancel()
context canceled
context.DeadlineExceeded
Pasó el tiempo de WithTimeout o WithDeadline
context 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"
)
funclistarTareas(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)
}
}
funcmain() {
// 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)
defercancel()
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:
Los tiempos del servidor: http.Server{ReadTimeout: …, WriteTimeout: …}, para clientes lentos o colgados.
http.TimeoutHandler(handler, 5*time.Second, "tardó demasiado"), que pone un tiempo máximo a cada petición y cancela su r.Context().
context.WithTimeout dentro del handler para una parte concreta (la llamada a una API lenta).
Primer parámetro y llamado ctx: func Buscar(ctx context.Context, id int) (Tarea, error). Todo el mundo lo escribe igual.
No lo guardes en un struct: pásalo en cada llamada. Un repositorio vive mucho; una petición, poco.
Siempre defer cancel() justo después de WithCancel o WithTimeout, aunque todo vaya bien: libera el temporizador.
context.Background() solo en main(), en los tests o al arrancar. Dentro de un handler, r.Context().
Quien hace algo lento escuchactx.Done() (en un select) o pasa el ctx a quien lo escuche.
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 · ✓ Resuelto
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
Pista. Al principio del cuerpo del for: if ctx.Err() != nil { return hechas }. Un contexto cancelado devuelve un error distinto de nil en ctx.Err().
Reto 2 de 3 · ✓ Resuelto
Búsqueda con tiempo máximo
BuscarConLimite(limite time.Duration, buscar func() string) (string, error) llama a buscar y espera lo que haga falta. Haz que espere como mucho limite: crea un contexto con context.WithTimeout (y su defer cancel()), lanza buscar en una goroutine que mande el resultado por un canal con buffer de 1 y usa select con ctx.Done(). Si se acaba el tiempo, devuelve "" y ctx.Err(). Es el CURLOPT_TIMEOUT de PHP para cualquier función.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista.ctx, cancel := context.WithTimeout(context.Background(), limite) y defer cancel(). Después, resultado := make(chan string, 1), go func() { resultado <- buscar() }() y un select con dos case: t := <-resultado y <-ctx.Done(). El buffer de 1 evita que la goroutine se quede atascada si ya nadie la espera.
Reto 3 de 3 · ✓ Resuelto
Un handler que se entera
ListarTareas llama a consultarBD con context.Background(), así que, aunque el cliente se vaya, sigue esperando y contesta 200. Cámbialo para que pase r.Context() y, si consultarBD devuelve un error, conteste con http.Error(w, "petición cancelada", http.StatusServiceUnavailable) (503) y salga. Si va bien, escribe 3 tareas. En PHP sería comprobar connection_aborted() antes de seguir.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Cambia context.Background() por r.Context(), guarda el error en err y, si no es nil, llama a http.Error(...) con http.StatusServiceUnavailable y haz return. Fíjate en que el import "context" sigue haciendo falta para consultarBD.
Resumen
Lo que te llevas de esta lección
ctx context.Context como primer parámetro de todo lo que pueda tardar (en PHP, cada cosa con su timeout suelto).
WithCancel para parar cuando digas; WithTimeout para parar solo; siempre defer cancel() (en PHP, el finally que libera).
Quien trabaja escucha <-ctx.Done() en un select y devuelve ctx.Err() (en PHP, connection_aborted() a mano).
errors.Is(err, context.DeadlineExceeded) = se acabó el tiempo (en PHP, CURLE_OPERATION_TIMEDOUT).
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.