Select para ordenar goroutines 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:006:43

Select para ordenar goroutines en Go

Curso de Go

Clase 22 de 28

Clase 22 / 28

Recursos

La palabra reservada select en Go es la pieza que ordena la ejecución de tus goroutines cuando trabajas con channels. Si ya dominas concurrencia básica, este operador te permite decidir el orden en que tu aplicación recibe resultados, evitando que una goroutine más rápida arruine la secuencia esperada.

Qué hace select dentro de Go y por qué importa

El operador select hace que tu aplicación espere la ejecución de un channel. Suena burocrático, pero es muy práctico: el channel espera a la goroutine, la goroutine corre en segundo plano, y cuando termina, el valor regresa al hilo principal sin fricción.

La función real de select es seleccionar la interrupción del ciclo de vida de un canal. Es decir, decide qué canal atender y en qué momento, lo que te da control sobre flujos concurrentes que de otra forma serían impredecibles.

¿Para qué sirve select en Go? Sirve para esperar y coordinar la respuesta de uno o varios channels, decidiendo el orden de ejecución de las goroutines asociadas y evitando condiciones de carrera en tu aplicación.

Cómo declarar channels y goroutines antes de usar select

Antes de invocar select necesitas la base: dos paquetes y dos canales listos para recibir datos.

En el ejemplo se importan fmt y time, y dentro de main se declaran dos canales de tipo cadena:

canal1 como chan string.
canal2 como chan string.
Dos goroutines que escriben mensaje uno y mensaje dos en cada canal.

Cada goroutine incluye un time.Sleep para mantener el hilo con vida un par de segundos antes de enviar el mensaje al canal correspondiente. Así simulas una tarea que tarda en resolverse, justo el escenario donde select brilla.

Cómo se escribe el bloque select con un for

El patrón clásico combina un ciclo for con select para escuchar varios canales en secuencia. En el ejercicio se usa:

go for i := 0; i <= 2; i++ { select { case mensaje1 := <-canal1: fmt.Println(mensaje1) case mensaje2 := <-canal2: fmt.Println(mensaje2) } }

select espera a que mensaje1 se ejecute, manda llamar al canal, y luego, en una segunda iteración, atiende mensaje2 con la goroutine del segundo canal. La salida llega ordenada porque select impone la pausa.

Por qué select tarda más y cómo aprovechar esa pausa

Al correr go run main.go notas que el proceso tarda un poco más. No es un error: select va por partes. Primero crea el canal, llama a la goroutine, espera el resultado, lo pasa al hilo principal, y solo entonces atiende la siguiente.

Esa dependencia de pasos es justo lo que necesitas cuando lanzas cinco goroutines y la número tres responde antes que la dos. Sin select, esa diferencia de velocidad rompe la lógica de tu aplicación. Con select, tú defines la secuencia.

¿Cuándo debo usar select en lugar de leer un channel directo? Úsalo cuando manejas dos o más channels simultáneos y necesitas decidir cuál atender primero, o cuando quieres aplicar timeouts para que tu programa no se quede bloqueado esperando.

Cómo encadenar el resultado de un canal con otra goroutine

Un ejercicio adicional muy útil es tomar el resultado de canal1 y enviarlo como entrada a la goroutine de canal2. Así ves cómo la secuencia acumula un conjunto mayor de cadenas en cada paso.

Este patrón te enseña tres cosas a la vez:

Cómo encadenar canales en pipeline.
Cómo select respeta el orden incluso cuando una tarea es más rápida.
Cómo los timeouts con time.Sleep o time.After te dan control sobre tiempos de espera excedidos.

Intenta replicarlo en tu editor, modifica los tiempos de cada Sleep y observa cómo select mantiene el orden aunque las goroutines terminen en momentos distintos. Cuéntame en los comentarios cómo te fue con la práctica y qué errores encontraste al encadenar los canales.

Jehú Frayle

Hace un año

Explicación del select en Go

Este tema me rompió la cabeza todo el día, así que hice un código con una metáfora con hamburguesas para explicarlo.

Primero, el código de mi ejemplo es el siguiente:

package main

import (
	"fmt"
	"time"
)

func main() {
	// Creamos un canal por cada ítem del pedido
	hamburguesa := make(chan string)
	papas := make(chan string)
	soda := make(chan string)

	// Simulamos la preparación de cada cosa en una goroutine distinta
	go prepararHamburguesa(hamburguesa)
	go prepararPapas(papas)
	go prepararSoda(soda)

	// Esperamos a que cada parte del pedido esté lista
	for i := 0; i < 3; i++ {
		select {
		case item := <-hamburguesa:
			fmt.Println("🍔 Pedido listo:", item)
		case item := <-papas:
			fmt.Println("🍟 Pedido listo:", item)
		case item := <-soda:
			fmt.Println("🥤 Pedido listo:", item)
		}
	}

	fmt.Println("✅ ¡El cliente ya tiene todo su pedido!")
}

// Simulan funciones de preparación con distintos tiempos

func prepararHamburguesa(ch chan string) {
	time.Sleep(3 * time.Second)
	ch <- "Hamburguesa con queso"
}

func prepararPapas(ch chan string) {
	time.Sleep(2 * time.Second)
	ch <- "Papas fritas"
}

func prepararSoda(ch chan string) {
	time.Sleep(1 * time.Second)
	ch <- "Soda fría"
}

Explicación

En este ejemplo, la go routines son los procesos separados que necesitamos para preparar cada parte de una orden. La concurrencia nos permite ejecutar estos procesos de manera simultánea, sin que se bloqueen entre ellos y aprovechando mejor los recursos y el tiempo.

✅ ¿Qué función cumple select?

No sé si es que yo entendí mal, pero me pareció que la clase da a entender que el select permite darles un orden de ejecucion a las rutinas, lo que no es correcto, al menos hasta lo que yo investigué.

El select en Go permite escuchar varios canales al mismo tiempo y ejecutar el primer caso que esté listo para entregar datos. Si vienes de JavaScript, es muy parecido a lo que hace Promise.Race().

En esta metáfora:

Es como si el cliente estuviera mirando tres ventanas al mismo tiempo (hamburguesa, papas, soda) esperando que la que termine primero le avise. Apenas una esté lista, va y la recoge.

Sin select, tendríamos que esperar a cada canal en orden, aunque ya esté lista la soda.

🔁 ¿Por qué necesitamos un for?

Como expliqué, select solo te devuelve el primer resultado en estar listo, "selecciona" uno. Después de eso termina su ejecución y pasa a lo siguiente.

El for se repite 3 veces porque tenemos 3 ítems diferentes que queremos recibir. Cada vuelta del ciclo espera uno de los canales.

Sin el for, solo se recogería uno de los productos y el programa terminaría antes de que lleguen los otros dos.

🛑 ¿Qué pasaría si usamos directamente la lectura de los canales en main?

Si escribimos esto:

item1 := <-hamburguesa
fmt.Println(item1)

item2 := <-papas
fmt.Println(item2)

item3 := <-soda
fmt.Println(item3)

Se ve más simple, pero no es concurrente al recibir. Aunque las goroutines ya trabajan en paralelo, los <-canal se ejecutan en orden. Eso significa que:

item1 := <-hamburguesa bloqueará el programa hasta que la hamburguesa esté lista, aunque la soda ya esté.
Estamos esperando fijo en orden, perdiendo el beneficio de saber qué sale primero.

Y no se confundan, no es que estemos ejecutando las funciones en ese momento. La go routines empezaron a ejecutarse desde el momento en que les dijimos go, pero no veremos el resultado hasta que la lectura de ese canal llegue en el código.

💥 ¿Y si me falta el pan y nunca hago la hamburguesa?

En caso de que un canal esté bloqueado el hilo de ejecución y este nunca reciba información, y por lo tanto, nunca se desbloquee, recibiremos un error deadlock.

Un deadlock es cuando un programa se queda esperando algo que nunca llega, y ninguna goroutine puede continuar. El programa se bloquea completamente.

En la metáfora: el cliente espera por una hamburguesa, pero el cocinero nunca empezó a cocinarla… y el cliente nunca se entera de que no viene. Se queda esperando para siempre.

⚠️ Ejemplo de deadlock en esta metáfora:

package main

func main() {
	hamburguesa := make(chan string)

	// No hay goroutine que cocine la hamburguesa...

	// El cliente espera por la hamburguesa, pero nadie la está preparando
	item := <-hamburguesa

	println(item)
}

🧨 Resultado:

El programa se queda congelado porque está esperando que llegue la hamburguesa, pero nadie la está enviando por el canal. Go imprimirá un error:

fatal error: all goroutines are asleep - deadlock!

🧯 ¿Cómo evitar deadlocks?

Asegúrate de que siempre haya una goroutine enviando o recibiendo si usas canales.
Usa select con cuidado cuando esperas múltiples canales.

Este tema es muchísimo más amplio, pero dejaré que lo vayamos descubriendo con el curso.

Este para mí es el conocimiento esencial para empezar a entender la concurrencia con Go, y justo como un canal, te podría bloquear en tu avance con el resto de las clases si no lo dominas.

Fabián Aravena Silva

Hace un año

Muchas gracias por la explicación.

Como dices, el select no garantiza el orden y se puede comprobar ejecutando el código un par de veces. En algún momento se imprimirá primero el mensaje 2.

Por otra parte, destacar que el código en el resumen de la clase resultará en un deadlock debido a que se está iterando 3 veces y sólo se esperan 2 mensajes. La tercera iteración espera por un mensaje que nunca llegará.

Leonardo Bucio

Hace un año

Excelente aporte, me causó conflicto igual lo de la estructura Select cuando dijo que era una ejecución secuencial.

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

Select para ordenar goroutines en Go