Timeouts en goroutines con time.After

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:49

Timeouts en goroutines con time.After

Curso de Go

Clase 23 de 28

Clase 23 / 28

Recursos

Cuando trabajas con goroutines y channels en Go, existe un riesgo silencioso: que una goroutine se quede procesando para siempre. Aquí entran los timeouts, una técnica que te permite definir cuánto tiempo esperar antes de cortar la espera y seguir con tu aplicación.

¿Por qué necesitas timeouts en goroutines y channels?

Imagina que lanzas una goroutine que envía su resultado a un channel, y un select espera ese resultado para continuar. Si algo falla (mala conexión, datos mal estructurados, un proceso que nunca termina) el channel mantiene su ciclo de vida activo y el select queda bloqueado.

Eso significa una aplicación colgada y un usuario frustrado esperando una respuesta que nunca llega. Los timeouts existen justamente para cortar ese hilo cuando excede el tiempo razonable.

¿Qué es un timeout en Go? Es un tiempo máximo de espera que defines para que una goroutine entregue su resultado a través de un channel. Si lo excede, tu programa toma otro camino en lugar de quedarse bloqueado.

¿Cómo implementar un timeout con time.After y select?

La pieza clave es el método time.After, que devuelve un channel después del tiempo que tú decidas. Combinado con select, te permite competir entre dos resultados: el de tu goroutine o el del temporizador.

El flujo básico es así:

Creas un channel donde la goroutine enviará su resultado.
Dentro de la goroutine, simulas o ejecutas un proceso que toma cierto tiempo.
Usas select con dos case: uno para recibir del channel y otro para time.After.
El que llegue primero es el que se ejecuta.

Ejemplo práctico con time.Sleep y time.After

En la demostración [00:53] se crea una carpeta timeouts con un archivo main.go, importando fmt y time. Dentro de main se define un channel de tipo string con capacidad para un elemento, y una goroutine que fuerza una espera de dos segundos con time.Sleep antes de enviar el resultado al channel.

go package main

import ( "fmt" "time" )

func main() { contador1 := make(chan string, 1)

go func() {
    time.Sleep(2 * time.Second)
    contador1 <- "resultado 1"
}()

select {
case resultado := <-contador1:
    fmt.Println("recibido", resultado)
case <-time.After(1 * time.Second):
    fmt.Println("timeout")
}

}

Aquí está la lógica: si la goroutine tarda dos segundos pero time.After solo da uno, el timeout gana. Al ejecutar go run main.go, la salida es timeout. La goroutine ni siquiera tiene oportunidad de entregar su resultado [03:13].

¿Qué pasa si el tiempo de espera es mayor al de la goroutine?

Si cambias time.After(1 * time.Second) por time.After(3 * time.Second), la goroutine ahora sí tiene margen para terminar su trabajo en sus dos segundos originales. La salida cambia a recibido resultado 1 [03:30].

Ese pequeño ajuste muestra cómo controlas con precisión cuánto estás dispuesto a esperar antes de tomar otra ruta.

¿Cómo aplicar timeouts en múltiples goroutines simultáneas?

Puedes replicar la misma estructura para varias goroutines y cada una tendrá su propio comportamiento según el tiempo que tarde. En la demostración [04:07] se agrega un contador2 con un tiempo distinto, dejando que una caiga en timeout y la otra entregue su resultado correctamente.

La ventaja es clara:

Cada goroutine se evalúa de forma independiente.
Detectas rápidamente cuál proceso es lento o problemático.
Tu aplicación nunca depende del peor caso de un proceso colgado.

¿Cuándo debo usar timeouts con channels? Siempre que uses channels para recibir resultados de goroutines. Sin un timeout, tu aplicación puede esperar indefinidamente un resultado que nunca llegará.

¿Qué buenas prácticas seguir al usar timeouts en Go?

La recomendación final es directa: implementa timeouts en todo momento que uses channels. Sin ellos, podrías estar esperando un resultado que nunca llegará, provocando que tu aplicación colapse o que el usuario abandone por falta de respuesta.

Algunos puntos a tener en cuenta:

Define tiempos realistas según el tipo de operación (red, base de datos, cálculo).
Maneja el caso del timeout con un mensaje claro o una acción alternativa.
Combina select con time.After como patrón estándar para procesos asíncronos.

Con esta técnica coronas la implementación de un select robusto en Go. ¿En qué parte de tu código crees que un timeout te habría salvado de un bloqueo? Cuéntame tu caso en los comentarios.

Samuel Soto Hoyos

Hace un año

Al asignar capacidad a un canal en Go, la buena práctica radica en entender el comportamiento de bloqueo que la capacidad introduce y elegirla en función de sus necesidades específicas de comunicación y sincronización.

Existen dos tipos principales de canales basados en su capacidad:

Canales sin búfer (unbuffered channels):
- Se crean con una capacidad de cero o sin especificarla: make(chan Tipo) o make(chan Tipo, 0).
- Las operaciones de envío y recepción en un canal sin búfer se bloquean hasta que tanto el emisor como el receptor están listos.
- Esto significa que la comunicación a través de un canal sin búfer también actúa como un punto de sincronización entre dos goroutines, asegurando que ambas se encuentren en un estado conocido en el momento de la comunicación. Son ideales para situaciones en las que se requiere un "rendezvous" o una sincronización estricta.
Canales con búfer (buffered channels):
- Se crean especificando una capacidad mayor que cero: make(chan Tipo, N) donde N es la capacidad del búfer.
- Una operación de envío solo se bloquea si el búfer está lleno.
- Una operación de recepción solo se bloquea si el búfer está vacío.
- Esto permite cierto desacoplamiento entre el emisor y el receptor. El emisor puede enviar valores al canal sin bloquearse, siempre y cuando haya espacio disponible en el búfer, y el receptor puede recibirlos más tarde.
- Los canales con búfer pueden utilizarse como un semáforo para limitar la concurrencia o el rendimiento. Por ejemplo, se puede iniciar un número fijo de goroutines que leen de un canal de solicitudes, limitando así las llamadas simultáneas a una función de procesamiento.
- La capacidad del búfer (argumentos n y m en make) debe ser un tipo entero, no negativo y representable por un valor de tipo int. Si n y m son constantes y se proporcionan ambos, n no debe ser mayor que m. Un valor negativo o n mayor que m en tiempo de ejecución causará un panic.

Consideraciones adicionales para una buena práctica:

Evite el uso excesivo de búferes: Aunque los búferes pueden desacoplar, asignar una capacidad excesivamente grande que no se utilice puede llevar a un uso ineficiente de la memoria, ya que los valores se almacenan en el heap (montón) y requieren gestión por parte del recolector de basura.
Canales nil: Un canal con valor nil nunca está listo para la comunicación y cualquier intento de enviar o recibir de él se bloqueará indefinidamente.
Seguridad en concurrencia: Los canales de Go están diseñados para ser seguros y pueden ser utilizados por cualquier número de goroutines para enviar y recibir valores sin necesidad de sincronización adicional, ya que actúan como colas FIFO (primero en entrar, primero en salir).

En resumen, la elección de la capacidad del canal (cero para sin búfer o un valor N para con búfer) debe estar directamente ligada al patrón de comunicación y los requisitos de sincronización que su programa necesita.

Josué Merino

Hace 9 meses

Muchas gracias, ha sido muy esclarecedor

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Timeouts en goroutines con time.After