Go routines y channels: programación asíncrona en Go

Clase 21 de 28 • Curso de 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

Resumen

La programación asíncrona en Go puede mejorar significativamente el desempeño de tus aplicaciones. Un recurso clave para lograrlo son las Go routines y los channels, herramientas básicas y prácticas de Go, que facilitan el manejo de procesos simultáneos sin complicados comandos.

¿Qué son las go routines y cómo funcionan?

Las go routines son funciones que permiten la ejecución asíncrona de procesos, trabajando como hilos secundarios en paralelo al hilo principal. Su manejo es sorprendentemente sencillo: basta con agregar la palabra reservada go antes de la llamada a la función.

La go routine parte del hilo principal, ejecuta su proceso y regresa automáticamente:

No requiere palabras clave complejas como async o await.
Mejora significativamente la rapidez en el procesamiento de datos.
Para evitar que la aplicación termine antes que las go routines, se utiliza una espera manual, como ocurre al agregar:

import "time"

time.Sleep(time.Second)

Este simple método garantiza que la aplicación espere un tiempo suficiente para finalizar los procesos asíncronos y obtener los resultados esperados.

¿Cómo usar channels junto con las go routines?

Los channels o canales en Go son complementos ideales para las go routines:

Facilitan el manejo y la sincronización de los datos enviados y recibidos entre go routines.
Se declaran usando la palabra reservada make, similar a mapas (maps) o listas dinámicas (slices), por ejemplo:

mensajes := make(chan string)

Una función rutinaria con canales podría verse así:

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

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

En este ejemplo:

El canal espera el procesamiento de la go routine sin necesidad de instrucciones directas.
Una vez recibido el mensaje, el canal automáticamente finaliza su ciclo de vida y puede ser cerrado.

Se pueden implementar múltiples canales simultáneamente sin interferencias entre sus procesos, cada uno con su propio ciclo de vida.

¿En qué mejora la integración de go routines y channels?

La combinación de go routines y channels potencia las capacidades asíncronas del lenguaje Go rápidamente y con poca complejidad. Sus ventajas principales son:

Rapidez y escalabilidad al manejar varias tareas simultáneamente.
Facilidad en la escritura de código asíncrono claro y legible.
Control fiable del final y manejo automático del flujo entre go routines y el hilo principal.

Conocer go routines y channels es fundamental para aprovechar al máximo el rendimiento que Go ofrece en tus desarrollos.

¿Has tenido ya la oportunidad de probar estas herramientas en tus aplicaciones? Comparte tu experiencia o sugerencias.

Comentarios

Samuel Soto Hoyos

student•

¿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.

Jehú Frayle

student•

Para entender los canales y su sintaxis, me gusta imaginarlos como tuberías.

Juan Camilo Grisales Arias

student•

Una de las mejores características de Go

Andres de Jesus Romo Quintero

student•

Las goroutines en Go no son hilos en el sentido tradicional del sistema operativo, aunque pueden parecerlo desde el punto de vista del programador. Aquí te explico la diferencia con precisión:

¿Qué es un hilo (thread)?

Un hilo del sistema operativo (OS thread) es una unidad de ejecución gestionada por el sistema operativo. Cada hilo tiene su propia pila (stack) y compite por recursos del sistema. Crear muchos hilos puede ser costoso en términos de memoria y contexto de ejecución.

¿Qué es una goroutine?

Una goroutine es una unidad de ejecución ligera gestionada por el runtime de Go, no por el sistema operativo directamente.

Características clave:

Ligera: consume muy poca memoria (comienza con 2 KB de stack).
Escalable: puedes lanzar cientos de miles de goroutines sin afectar seriamente el rendimiento.
Multiplexadas: el runtime de Go asigna muchas goroutines a pocos hilos del sistema operativo.
No paralelas por defecto: aunque puedes lanzar muchas goroutines, Go solo las ejecutará en paralelo si permites múltiples núcleos con GOMAXPROCS.

¿Cómo funcionan internamente?

El runtime de Go usa un modelo llamado M:N scheduling:

M (Machine): hilos del sistema operativo.
N (Goroutines): rutinas ligeras que se ejecutan.
El runtime mapea muchas goroutines sobre pocos hilos, usando un planificador cooperativo.

José Cortés Molina

student•

Sí, chan es la palabra reservada en Go para declarar un canal. Los canales son utilizados para comunicar goroutines y permiten el paso de datos entre ellas de manera segura. Puedes crear un canal de un tipo específico utilizando la sintaxis make(chan Tipo). Esto facilita la programación concurrente al permitir que diferentes goroutines se sincronicen y se comuniquen sin conflictos.

Samuel Soto Hoyos

student•

También puedes asignar la capacidad del canal con: make(chan Type, Cap).

Ronaldo Jiménez

student•

Dejo estos recursos sobre este tema tan interesante:

Repo:

Tutorial, 🧵 Concurrencia en Go: Introducción:

Tutorial, Goroutines, Canales, Mutex y WaitGroups en Acción:

Ronaldo Jiménez

student•

package concurrency

import (
	"fmt"
	"time"
)

func Goroutines() {
	// Lanzamos dos goroutines (ejecución concurrente)
	go tarea("🌞 Desayunar", 2)   // 2 segundos
	go tarea("📚 Estudiar Go", 4) // 4 segundos

	// Esperamos para que no termine el programa
	time.Sleep(5 * time.Second)
	fmt.Println("✅ Todas las tareas completadas")
}

func tarea(nombre string, segundos int) {
	fmt.Printf("▶️ Iniciando: %s\n", nombre)
	time.Sleep(time.Duration(segundos) * time.Second)
	fmt.Printf("🏁 Terminado: %s\n", nombre)
}

José Cortés Molina

student•

Sí, en Go, la declaración de un canal se hace utilizando la palabra clave make junto con chan. Por ejemplo, messages := make(chan string) declara un canal llamado messages que puede enviar y recibir cadenas. Esto permite la comunicación entre goroutines y es fundamental para la programación concurrente en Go.

package concurrency

import (
	"fmt"
	"time"
)

func Goroutines() {
	// Lanzamos dos goroutines (ejecución concurrente)
	go tarea("🌞 Desayunar", 2)   // 2 segundos
	go tarea("📚 Estudiar Go", 4) // 4 segundos

	// Esperamos para que no termine el programa
	time.Sleep(5 * time.Second)
	fmt.Println("✅ Todas las tareas completadas")
}

func tarea(nombre string, segundos int) {
	fmt.Printf("▶️ Iniciando: %s\n", nombre)
	time.Sleep(time.Duration(segundos) * time.Second)
	fmt.Printf("🏁 Terminado: %s\n", nombre)
}

Go routines y channels: programación asíncrona en Go

Introducción y Configuración

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

Instalación de Go en Ubuntu con WSL y Visual Studio Code

Gestión de paquetes e imports en Go

Fundamentos de Go

Declaración de variables básicas en Go

Conversión entre tipos de datos numéricos y cadenas en Go

Condicionales if y else en Go con operadores básicos

Sintaxis y variaciones del ciclo for en Go

Estructuras de Datos y Funciones

Uso de la sentencia switch en Go para selección condicional

Declaración y uso básico de arreglos en Go

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

Funciones con múltiples valores de retorno en Go

Funciones variádicas en Go para múltiples parámetros

Funciones recursivas en Go para cálculos matemáticos

Punteros en Go para optimizar rendimiento del sistema

Runas y caracteres Unicode en Go: optimización de memoria

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 para mejor depuración

Go routines y channels: programación asíncrona en Go

Operador select para controlar Go routines y canales en Go

Implementación de timeouts en Go con select y time.After

Implementación práctica de workers con canales y goroutines en Go

Buenas Prácticas en Go

Conversión entre JSON y objetos en Go con Marshal y Unmarshal

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