Goroutines y channels en Go

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:0010:52

Goroutines y channels en Go

Curso de Go

Clase 21 de 28

Clase 21 / 28

Recursos

La concurrencia en Go se resuelve con dos piezas que trabajan juntas: goroutines y channels. Si vienes de otros lenguajes con async/await, aquí descubrirás una sintaxis más simple para correr código en paralelo, sincronizar hilos y devolver resultados al flujo principal sin dolores de cabeza.

¿Qué es una goroutine en Go y cómo se ejecuta?

Una goroutine es una función que corre en un hilo asíncrono y devuelve el control al hilo principal cuando termina. La palabra reservada go antes de una llamada es todo lo que necesitas para lanzarla [01:02].

Para verlo en acción, dentro de una carpeta goroutine se crea un main.go que importa el paquete time y declara una función con un argumento from string que ejecuta un for tres veces con fmt.Println [02:00].

go func function(from string) { for i := 0; i < 3; i++ { fmt.Println(from, ":", i) } }

En modo directo, basta con function("directo") dentro de main y la salida aparece sin sorpresas. El cambio interesante ocurre al anteponer go:

go go function("goroutine")

¿Por qué mi goroutine no imprime nada? Porque el programa principal terminó antes de que el segundo hilo devolviera el resultado. La goroutine muere con el ciclo natural de la aplicación.

¿Cómo espero a que termine una goroutine?

Una solución rápida es usar time.Sleep para darle margen al hilo secundario [05:30]. También puedes declarar una goroutine anónima en línea con go func() { ... }() y ejecutarla una sola vez.

go go func(msg string) { fmt.Println(msg) }("goroutine anónima")

time.Sleep(time.Second) fmt.Println("Fin del programa")

El detalle simpático de la sintaxis de Go es que no existen async ni await: la palabra go se encarga de toda la orquestación. Aun así, depender de Sleep es frágil. Aquí entran los canales.

¿Qué son los channels en Go y para qué sirven?

Un channel es una estructura que permite a una goroutine enviar datos al hilo principal y, de paso, sincronizar la espera. Se declara con make y la palabra reservada chan seguida del tipo que va a transportar [07:45].

go mensajes := make(chan string)

go func() { mensajes <- "ping" }()

mensaje := <-mensajes fmt.Println(mensaje)

El operador <- cumple dos roles: enviar un valor al canal cuando aparece a la derecha de la variable, y recibirlo cuando aparece a la izquierda. La gran diferencia con el ejemplo de Sleep es que el canal espera por sí mismo a que la goroutine termine.

¿Para qué uso un channel en lugar de Sleep? Para que el hilo principal espere de forma natural el resultado de la goroutine sin temporizadores. El canal recibe el valor, lo entrega y se cierra cuando termina su ciclo de vida.

¿Puedo usar varios channels y goroutines a la vez?

Sí, y es donde la programación asíncrona se vuelve cómoda. Puedes declarar un segundo canal independiente del primero, lanzar otra goroutine y leer su mensaje sin que ambos se interfieran [10:20].

go go func() { mensajes <- "pong" }()

segundoMensaje := <-mensajes fmt.Println(segundoMensaje)

Cada canal vive su propio ciclo: se crea, transporta el valor, lo entrega y se libera. Esto te permite encadenar tareas concurrentes sin coordinar manualmente los tiempos.

¿Cuándo conviene usar goroutines y channels juntos?

La combinación brilla cuando necesitas procesamiento paralelo con sincronización: lecturas a APIs, trabajos en background, pipelines de datos o cualquier tarea donde el hilo principal dependa de un resultado externo.

Algunos casos prácticos donde la dupla aporta valor:

Ejecutar varias llamadas concurrentes y recibir cada respuesta por su propio canal.
Distribuir trabajo entre hilos del procesador para acelerar tareas pesadas.
Coordinar productores y consumidores sin escribir lógica de bloqueo manual.

La palabra reservada go, la función make aplicada a chan string y el operador <- son las tres piezas mínimas que necesitas memorizar. Con eso, tus aplicaciones en Go pueden trabajar con múltiples hilos, devolver información al flujo principal y mantener la sintaxis limpia.

¿Ya probaste portar una función bloqueante a una goroutine con channel? Cuenta en los comentarios qué caso de tu proyecto te gustaría resolver con concurrencia.

Samuel Soto Hoyos

Hace un año

¿Qué es un canal en Go?

Los canales son un mecanismo principal para la concurrencia en Go. Son una parte clave de las características de concurrencia de Go, integradas directamente en el lenguaje

Propósito y Naturaleza:
- Los canales permiten que las funciones que se ejecutan concurrentemente (gorutinas) se comuniquen entre sí enviando y recibiendo valores.
- La filosofía central de Go para la concurrencia es: "No te comuniques compartiendo memoria; en su lugar, comparte memoria comunicándote". Esto significa que, en lugar de usar bloqueos y mutexes alrededor de datos compartidos, los canales se utilizan para pasar los datos entre las gorutinas, asegurando que solo una gorutina tenga acceso a un valor en un momento dado.
- Un canal es un valor de primera clase en Go, lo que significa que puede ser asignado y pasado como cualquier otro valor. Esto es crucial para la implementación de patrones de concurrencia avanzados.
- Actúan como conductos tipados (typed conduits), lo que permite el paso de datos entre gorutinas y la sincronización de su estado de ejecución.
- Los canales combinan comunicación y sincronización en una sola operación.
Tipos de Canales:
- Canales sin búfer (síncronos): Estos canales tienen una capacidad de cero. La comunicación a través de un canal sin búfer solo tiene éxito cuando tanto un emisor como un receptor están listos. Si el emisor intenta enviar y no hay un receptor listo, el emisor se bloquea; si un receptor intenta recibir y no hay datos, el receptor se bloquea. Esto crea un punto de sincronización "paso a paso" (lockstep position) entre las gorutinas.
- Canales con búfer: Se crean especificando una capacidad mayor que cero (ej., make(chan int, 100)). Un envío en un canal con búfer no bloquea al emisor a menos que el búfer esté lleno. Un recibo sigue bloqueando si el búfer está vacío. Los canales con búfer pueden usarse como un semáforo para limitar el rendimiento o la concurrencia.

Casos para Lectura y Escritura (Operaciones de Envío y Recepción)

Las operaciones de envío y recepción son fundamentales para interactuar con los canales.

Sintaxis:
- Declaración e Inicialización:
  - Declarar una variable de tipo canal: var c chan int.
  - Inicializar un canal (sin búfer): c := make(chan int).
  - Inicializar un canal con búfer: cs := make(chan *os.File, 100).
- Envío de Valores:
  - Se usa el operador <- apuntando hacia el canal: ch <- 3 (envía el valor 3 al canal ch).
- Recepción de Valores:
  - Se usa el operador <- apuntando fuera del canal: v1 := <-ch (recibe un valor del canal ch y lo asigna a v1).
  - Una forma especial de recepción de múltiples valores, x, ok = <-ch o x, ok := <-ch, devuelve un valor booleano adicional (ok) que indica si la comunicación fue exitosa (true) o si el valor recibido es el valor cero porque el canal está cerrado y vacío (false).
Comportamiento de Bloqueo:
- Canales nil: Enviar o recibir de un canal nil siempre se bloquea indefinidamente y no causa un panic. Esta propiedad es útil para deshabilitar dinámicamente casos en una sentencia select.
- Canales cerrados:
  - Enviar a un canal cerrado causa un run-time panic.
  - Recibir de un canal cerrado puede continuar inmediatamente después de que todos los valores enviados previamente hayan sido recibidos. Los valores posteriores serán el valor cero del tipo del elemento del canal, sin bloquear.
Canales Direccionales:
- Un canal puede ser restringido para enviar solo (chan<- T) o recibir solo (<-chan T) mediante asignación o conversión explícita.
- chan T (bidireccional): puede enviar y recibir valores de tipo T.
- chan<- float64 (send-only): solo puede enviar float64.
- <-chan int (receive-only): solo puede recibir int.
- El operador <- se asocia con el chan más a la izquierda posible en una declaración.

Buenas Prácticas para Manejar Canales

El uso efectivo de los canales puede llevar a código concurrente robusto y fácil de entender.

Compartir Memoria Mediante Comunicación: Siempre que sea posible, sigue la máxima de Go de compartir memoria comunicándose. Esto ayuda a evitar condiciones de carrera (data races). El detector de carreras de Go (go run -race) es una herramienta valiosa para identificar estas condiciones.
Serialización del Acceso al Estado Mutable: Utiliza un patrón de bucle for-select donde el estado mutable es "propiedad" de una única gorutina y solo se accede a él a través de los casos del select. Esto elimina las condiciones de carrera ya que es código secuencial dentro de una gorutina.
Manejo de Múltiples Eventos con select: La sentencia select es fundamental para responder a diferentes tipos de eventos concurrentes, como la recepción de datos, la cancelación o los timeouts
Timeouts en Comunicaciones: Emplea select junto con time.After para implementar timeouts. Esto asegura que las operaciones no se bloqueen indefinidamente si no hay respuesta dentro de un período de tiempo determinado.
Cancelación y Cierre de Gorutinas:
- Implementa un mecanismo de cancelación utilizando un canal dedicado (por ejemplo, un canal quit).
- Asegúrate de que las gorutinas que no son necesarias terminen su ejecución de manera controlada para evitar fugas de gorutinas (goroutine leaks). Una gorutina que está en un bucle infinito o bloqueada en un canal sin recibir una señal de cierre puede permanecer activa indefinidamente.
- Es una buena práctica que la gorutina que recibe la señal de cierre, realice sus tareas de limpieza y luego envíe una señal de confirmación de vuelta para indicar que ha terminado.
Deshabilitar Casos de select Dinámicamente: Una técnica potente es establecer un canal a nil para deshabilitar su caso correspondiente dentro de un select. Esto simplifica la lógica y evita la necesidad de múltiples estructuras select para diferentes escenarios.
Evitar Bloqueos por Operaciones Lentas (E/S): Si una operación (ej. una llamada a fetch que involucra E/S) puede tardar mucho, ejecútala en una gorutina separada. Los resultados se envían de vuelta a la gorutina principal a través de un canal, manteniendo la lógica principal receptiva.
Gestión de Recursos y Contrapresión (Backpressure):
- Usa canales con búfer para limitar la concurrencia, actuando como semáforos. Por ejemplo, para procesar un número máximo de solicitudes concurrentes.
- Puedes limitar el crecimiento de colas internas (ej. pending items) controlando cuándo se programan las operaciones de fetch o envío, usando la misma técnica de canales nil si el búfer está lleno.
Iteración sobre Canales con for-range: Para consumir valores de un canal hasta que se cierre, el bucle for item := range ch es la forma idiomática y limpia de hacerlo. El close de un canal es importante para que estos bucles terminen correctamente.
Evitar la Concurrencia Excesiva: Aunque Go facilita la concurrencia, no la uses para todo. Para tareas simples, como contadores de referencia, los paquetes sync y sync/atomic que proporcionan primitivas de bajo nivel pueden ser más apropiados y eficientes que una gorutina y un canal. Utiliza la herramienta adecuada para el trabajo.
Pruebas de Código Concurrente:
- Los canales pueden ser utilizados para simular (mock) servicios externos en pruebas, ya que su interfaz abstracta es el canal mismo.
- Go 1.1 y versiones posteriores incluyen un detector de carreras (-race flag) que ayuda a encontrar errores de concurrencia al momento de la ejecución.
- El detector de deadlock del runtime de Go es útil, ya que reporta si todas las gorutinas están bloqueadas con sus respectivos stack traces. Esto es especialmente útil en pruebas unitarias.

Los canales son una herramienta potente y flexible en Go, permitiendo la construcción de programas concurrentes robustos y reactivos para sistemas complejos y distribuidos.

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

Goroutines y channels en Go