Workers en Go con goroutines y channels

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:009:43

Workers en Go con goroutines y channels

Curso de Go

Clase 24 de 28

Clase 24 / 28

Recursos

Los workers en Go te permiten ejecutar tareas en segundo plano usando goroutines y channels, ideales para procesos que se disparan por eventos o se repiten en intervalos. Si ya conoces goroutine, channel, select y timeout, tienes todo lo necesario para construirlos paso a paso.

¿Qué es un worker y para qué sirve en programación concurrente?

Un worker es un servicio latente que espera a que algo lo desencadene. Piensa en un proceso que limpia tu disco duro cada 24 horas o que reacciona a un evento dentro de una aplicación distribuida.

¿Qué hace un worker en Go? Ejecuta tareas en segundo plano usando goroutines, recibe trabajo por un channel de entrada y entrega resultados por un channel de salida.

La fuerza del patrón está en desacoplar quién pide el trabajo de quién lo ejecuta. Tú lanzas varios workers, ellos toman tareas del canal y devuelven resultados sin bloquear el hilo principal.

¿Cómo se construye la función worker en Go?

La función worker recibe tres argumentos: un identificador entero, un channel de tareas y un channel de resultados. Ambos canales son de tipo int en este ejemplo.

Dentro de la función, un for con range recorre el canal de tareas. Por cada tarea entrante, el worker imprime un mensaje, espera con time.Sleep(time.Second) para simular trabajo, y envía el resultado multiplicado por dos al canal de resultados.

go package main

import ( "fmt" "time" )

func worker(id int, tareas <-chan int, resultados chan<- int) { for j := range tareas { fmt.Println("worker", id, "procesando tarea", j) time.Sleep(time.Second) fmt.Println("worker", id, "tarea iniciada", j) resultados <- j * 2 } }

Una nota práctica: si quieres formatear cadenas con variables, usa Printf con verbos como %d. Si solo concatenas, Println funciona perfecto.

¿Por qué usar channels para tareas y resultados?

Los canales sincronizan la comunicación entre goroutines sin necesidad de mutex manuales. El canal de tareas alimenta a los workers, el de resultados recoge la salida.

¿Cómo orquestar los workers desde main?

En main defines una constante con el número de tareas, creas los dos canales con make y lanzas varios workers en goroutines.

Declara const numeroTareas = 5 para fijar la cantidad de iteraciones.
Crea los canales con make(chan int, numeroTareas) para tareas y resultados.
Lanza los workers con un for que itere por ejemplo de w := 1 hasta menor que 3, ejecutando go worker(w, tareas, resultados).

Un segundo for envía las tareas al canal y luego llama a close(tareas) para indicar que no habrá más trabajo. Sin ese cierre, los workers seguirían esperando para siempre.

¿Qué hace close() en un channel? Cierra el canal e indica a los receptores que ya no llegarán más valores. Es esencial cuando usas range sobre un canal.

Finalmente, un tercer for lee del canal de resultados tantas veces como tareas enviaste. Aquí es donde la información llega al hilo principal y puedes mostrarla.

go func main() { const numeroTareas = 5 tareas := make(chan int, numeroTareas) resultados := make(chan int, numeroTareas)

for w := 1; w < 3; w++ {
    go worker(w, tareas, resultados)
}

for j := 1; j <= numeroTareas; j++ {
    tareas <- j
}
close(tareas)

for a := 1; a <= numeroTareas; a++ {
    <-resultados
}

}

¿Por qué los resultados aparecen en desorden?

Al ejecutar go run main.go notarás algo curioso: la tarea 4 puede iniciarse mientras la 3 todavía arranca. Los workers trabajan en paralelo y entregan resultados según terminan, no según entran.

Esto rompe el patrón FIFO (First In, First Out). Cuando trabajas con hilos, la comunicación se vuelve asíncrona y el orden de salida depende de cómo el runtime programa cada goroutine.

¿Por qué los workers no respetan el orden FIFO? Porque varios hilos procesan tareas al mismo tiempo. El que termine primero entrega su resultado primero, sin importar el orden de entrada.

Si tu lógica depende del orden, debes planearlo. Aquí entran herramientas como select y timeout para darle estructura a la concurrencia y evitar que el desorden se convierta en un problema.

Conceptos y habilidades clave del ejercicio

El ejercicio integra varios elementos de Go que vale la pena identificar dentro del código:

Goroutine: ejecutas worker en segundo plano con go worker(...), sin bloquear main.
Channel: make(chan int, numeroTareas) crea canales con buffer para tareas y resultados.
range sobre canal: recorre tareas hasta que el canal se cierra.
close: cierra el canal de tareas y libera al range del worker.
time.Sleep(time.Second): simula la duración de cada tarea.
Println vs Printf: el primero concatena, el segundo aplica formato con verbos.

Practica modificando el número de workers, agregando un select con timeout o forzando un orden de salida con estructuras adicionales. Cuéntame en los comentarios qué escenario de worker implementarías primero en tu proyecto.

Samuel Soto Hoyos

Hace un año

defer

La sentencia defer en Go se utiliza para programar una llamada a función (la función diferida) para que se ejecute inmediatamente antes de que la función que contiene el defer retorne. Es una característica distintiva de Go para manejar situaciones como la liberación de recursos, asegurando que se realice la limpieza necesaria independientemente de la ruta que tome la función para retornar.

Características y Comportamiento:

Evaluación de argumentos: Los argumentos de la función diferida (incluido el receptor si es un método) se evalúan en el momento en que se ejecuta la sentencia defer, no cuando la llamada real a la función diferida se produce. Esto significa que los valores de las variables capturadas se fijan en el momento del defer.
Orden de ejecución (LIFO): Las funciones diferidas se ejecutan en orden LIFO (último en entrar, primero en salir). Si se difieren múltiples funciones, la última en ser diferida será la primera en ejecutarse.
Momento de ejecución: Las funciones diferidas se ejecutan justo antes de que la función envolvente retorne, ya sea por una sentencia return explícita, por alcanzar el final de su cuerpo, o porque la goroutine correspondiente está en estado de "panic". Si la función envolvente retorna a través de un return explícito, las funciones diferidas se ejecutan después de que cualquier parámetro de resultado haya sido establecido por la sentencia return, pero antes de que la función retorne a su invocador. Si la función diferida tiene valores de retorno, estos se descartan.

Buenas Prácticas y Casos de Uso Comunes para defer:

Liberación de recursos: Es su uso canónico. Permite que la sentencia de cierre de un recurso (como un archivo o un mutex) se coloque cerca de su apertura o adquisición, garantizando que el recurso se libere incluso si la función tiene múltiples puntos de salida o encuentra un error.
- Ejemplo: Cierre de archivos (f.Close()) o desbloqueo de mutexes (l.Unlock()).
Manejo de panic y recover: defer es crucial para la función recover. recover solo es útil dentro de funciones diferidas y permite que un programa recupere el control de una goroutine que está entrando en pánico, evitando que todo el programa termine. Esto es especialmente útil en servidores para aislar goroutines fallidas.
Trazabilidad/Debugging: Se puede usar para registrar entradas y salidas de funciones (trazas), lo que ayuda a depurar el flujo de ejecución.

close

La función incorporada close se utiliza para registrar que no se enviarán más valores en un canal.

Características y Comportamiento:

Señalización de fin de envío: close indica a los receptores que el canal ha sido cerrado y que no se esperan más envíos.
Comportamiento de la recepción después de close: Después de llamar a close, y una vez que se hayan recibido los valores enviados previamente, las operaciones de recepción en ese canal retornarán el valor cero para el tipo del canal sin bloquearse.
Comprobación de cierre: La forma de asignación multi-valor del operador de recepción (v, ok := <-ch) puede usarse para determinar si un valor recibido fue enviado con éxito o si es un valor cero generado porque el canal está cerrado y vacío (ok será false si el canal está cerrado y vacío).
Uso con bucles for...range: En un bucle for...range sobre un canal, la iteración continúa recibiendo valores hasta que el canal se cierra. close es fundamental para terminar limpiamente estos bucles.
Condiciones de error (pánico):
- Es un error intentar close un canal de solo recepción.
- Enviar o cerrar un canal ya cerrado causará un "panic" en tiempo de ejecución.
- Cerrar un canal nil también causará un "panic" en tiempo de ejecución.

Buenas Prácticas para close:

Cierre de canales para señalización: Utiliza close para señalar a las goroutines que están recibiendo de un canal que no habrá más datos, permitiéndoles terminar sus bucles for...range de forma limpia.
Evitar fugas de goroutines: Asegúrate de que las goroutines que están esperando en un canal tengan una forma de salir. Si una goroutine está bloqueada indefinidamente esperando en un canal que nunca se cierra o que no tiene un remitente, puede resultar en una fuga de goroutine. El uso de select con una cláusula default o un canal de tiempo de espera (time.After) o un canal de "quit" puede ayudar a hacer las goroutines más receptivas y evitar bloqueos indefinidos.
Preferir Close explícitos sobre finalizadores/cleanups para recursos no relacionados con la memoria: Aunque Go tiene finalizadores y cleanups, las fuentes recomiendan encarecidamente proporcionar una API explícita (como un método Close) para liberar recursos no relacionados con la memoria (como descriptores de archivo) de forma determinista. Los finalizadores y cleanups deben considerarse como un último recurso o un manejador de "mejor esfuerzo" para errores de programación, ya que su tiempo de ejecución no es predecible y no hay garantía de que se ejecuten al salir del programa.
Preferir cleanups a finalizers (Go 1.24+): Para usos en Go 1.24 y versiones posteriores, se recomienda usar cleanups porque son más flexibles, menos propensos a errores y más eficientes que los finalizadores. Los finalizadores pueden resucitar el objeto al que están adjuntos, lo que puede impedir que la memoria sea liberada si el objeto forma parte de un ciclo de referencia.
Pruebas: Al probar código que utiliza cleanups, weak pointers o finalizers, es recomendable:
- Evitar ejecutar las pruebas en paralelo.
- Usar runtime.GC() para forzar la recolección de basura y la cola de cleanups/finalizers.
- Inyectar un mecanismo (como un canal) para bloquear la prueba hasta que la limpieza haya terminado, o bien comprobar el estado post-limpieza en un bucle.
- Ejecutar las pruebas en modo race para descubrir condiciones de carrera.

Principio Fundamental de Concurrencia en Go

Un principio clave en Go para el manejo de la concurrencia es: "No comunicarse compartiendo memoria; en su lugar, compartir memoria comunicándose". Esto significa que, en lugar de usar bloqueos y mutexes para proteger el acceso a datos compartidos, se fomenta el paso de datos entre goroutines a través de canales, donde solo una goroutine tiene acceso al valor en un momento dado, eliminando las condiciones de carrera por diseño. Herramientas como el detector de carreras (go build -race) son fundamentales para identificar y diagnosticar condiciones de carrera en programas Go.

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

Workers en Go con goroutines y channels