Operador select para controlar Go routines y canales en Go

Clase 22 de 28 • Curso de Go

Resumen

Dominar el uso de select con Go routines y canales en Go es muy útil para controlar de forma eficaz el flujo y sincronización de tus aplicaciones. Al emplear la palabra reservada select, obtienes un mecanismo que facilita la espera y control en la ejecución secuencial de Go routines utilizando canales.

¿Cuál es el rol del operador select en Go?

La función clave del operador select es esperar y coordinar la ejecución de canales en Go. Este operador permite a tu aplicación pausar su ejecución hasta recibir una señal específica del canal, optimizando así el manejo simultáneo de procesos en segundo plano.

El proceso sucede así:

Creas un canal que ejecutará una tarea en una Go routine.
El canal espera pacientemente hasta que dicho procesamiento finalice.
Una vez finalizado, el canal notifica al hilo principal para continuar con la ejecución.

Esto asegura sincronía y precisión en tareas que requieren secuencia estricta.

¿Cómo implementar canales y uso de select en código Go?

Para usar de manera efectiva select, primero define los canales y acompáñalos con una función en Go routine.

Mira este ejemplo práctico:

package main

import (
    "fmt"
    "time"
)

func main() {
    canalUno := make(chan string)
    canalDos := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        canalUno <- "Mensaje uno"
    }()

    go func() {
        time.Sleep(1 * time.Second)
        canalDos <- "Mensaje dos"
    }()

    for i := 0; i <= 2; i++ {
        select {
        case mensajeUno := <-canalUno:
            fmt.Println(mensajeUno)
        case mensajeDos := <-canalDos:
            fmt.Println(mensajeDos)
        }
    }
}

Este ejemplo muestra cómo:

Crear canales específicos para transmitir mensajes.
Usar go func() para ejecutar tareas simultáneamente.
El operador select espera resultados de los canales y procede de forma ordenada.

¿Qué problemas soluciona select al trabajar con Go routines?

Muchas veces, cuando implementas Go routines para procesos simultáneos, es posible que las tareas terminen en distintos tiempos. Por ejemplo, si tienes cinco Go routines trabajando al mismo tiempo, la tercera puede terminar antes que la segunda, generando errores o complicaciones en la secuencia lógica de la aplicación.

Con select, puedes manejar y decidir explícitamente en qué orden recibir los resultados de estas Go routines, garantizando así que tu aplicación funcione correctamente y sin errores imprevistos.

Ejercicio recomendado para practicar con select

Para fortalecer tus habilidades, puedes realizar este ejercicio:

Haz que el resultado de una Go routine inicial pase directamente como entrada a otra Go routine.
Comprueba cómo se va acumulando información secuencialmente.

Te animo a intentarlo y compartir tus avances en los comentarios. ¡Sigue practicando y avanzando en tu aprendizaje!

Jehú Frayle

student•

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

student•

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

student•

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

Moises Almonte

student•

Esta clase me dejo con algunas dudas. Según la documentación de Go en Tour.

La instrucción select, bloquea hasta que uno de sus case pueda ejecutarse; luego, lo ejecuta. Si hay varios disponibles elige uno al azar.

Fuente: https://go.dev/tour/concurrency/5

package main

import (
	"fmt"
	"time"
)

func main(){
	canal1 := make(chan string)
	canal2 := make(chan string)
	canal3 := make(chan string)

	go saludo("Juan", canal1, 4)
	go saludo("Nico", canal2, 1)
	go saludo("Kelvin", canal3, 2)

	for i := 1; i <= 3; i++ {
		select{
		case saludo1 := <- canal1:
			fmt.Println("#1", saludo1)
		case saludo2 := <- canal2:
			fmt.Println("#2", saludo2)
		case saludo3 := <- canal3:
			fmt.Println("#3", saludo3)
		}
	}

}

func saludo(name string, canal chan string, s time.Duration){
	saludo := fmt.Sprintf("Welcome %s", name)
	time.Sleep(s * time.Millisecond)
	canal <- saludo
}

//Output #2 Welcome Nico #3 Welcome Kelvin #1 Welcome Juan

Abinadi Contreras

student•

Elige uno al azar, y en la proxima iteracion envia el otro, hasta que se cumplan las 3 iteraciones de las tres gorutines

Abinadi Contreras

student•

Sin Select se espera que el programa procese todas las Gorutines.

Con select seria la verdadera concurrencia, la que termine primero esa sale a la proxima fase primero.

Jose Miguel Valero Reyes

student•

package main

import (
	"fmt"
	"time"
)

func main() {
	fuego := make(chan string)
	carne := make(chan string)
	birra := make(chan string)

	go generateMessage(fuego, "Fuego listo", 1*time.Second)
	go generateMessage(carne, "Carne lista", 2*time.Second)
	go generateMessage(birra, "Birra lista", 3*time.Second)

	for range 3 {
		select {
			case fuegoLento := <-fuego:
				fmt.Println("Recibido:", fuegoLento)
			case carneLenta := <-carne:
				fmt.Println("Recibido:", carneLenta)
			case birraLenta := <-birra:
				fmt.Println("Recibido:", birraLenta)
		}
	}
	fmt.Println("listo para comer y beber.")
}

func generateMessage(ch chan string, mensaje string, t time.Duration) {
	time.Sleep(t)
	ch <- mensaje
}

Samuel Soto Hoyos

student•

La sentencia select en Go es una estructura de control fundamental para la concurrencia que permite a las gorutinas esperar y reaccionar a múltiples operaciones de comunicación. Es similar a una sentencia switch, pero sus casos se refieren exclusivamente a operaciones de envío o recepción en canales.

A continuación, se detalla su funcionamiento:

Propósito y Naturaleza
- La sentencia select es una parte clave de las características de concurrencia de Go integradas directamente en el lenguaje, no como una simple biblioteca. Esto facilita el control y la comprensión del comportamiento del programa.
- Su objetivo principal es permitir que un programa controle su comportamiento basándose en qué comunicaciones están listas para proceder en un momento dado.
- Un select se bloquea hasta que uno de sus casos puede continuar.
Mecanismo de Funcionamiento (Pasos de Ejecución)
1. Evaluación de operandos: Al entrar en la sentencia select, los operandos de los canales en las operaciones de recepción y las expresiones del lado derecho en las operaciones de envío se evalúan una única vez y en orden de aparición en el código. Esto crea un conjunto de canales listos para recibir o enviar, y los valores correspondientes a enviar. Los efectos secundarios de esta evaluación ocurren independientemente de la operación de comunicación que se seleccione. Las expresiones del lado izquierdo de una sentencia de recepción con una declaración de variable corta o una asignación aún no se evalúan.
2. Selección de caso:
  - Si una o más comunicaciones pueden proceder, se elige una de ellas mediante una selección pseudoaleatoria uniforme.
  - Si ninguna comunicación puede proceder y hay un caso default, se elige este caso.
  - Si no hay un caso default, la sentencia select se bloquea hasta que al menos una de las comunicaciones pueda proceder.
3. Ejecución de la operación: A menos que el caso seleccionado sea el default, la operación de comunicación correspondiente se ejecuta.
4. Asignación de valores: Si el caso seleccionado es una sentencia de recepción con una declaración de variable corta o una asignación, las expresiones del lado izquierdo se evalúan y el valor (o valores) recibido(s) se asigna(n).
5. Ejecución de la lista de sentencias: Finalmente, se ejecuta la lista de sentencias del caso seleccionado.
Comportamiento con Canales nil y default
- Enviar o recibir de un canal nil siempre se bloquea, no causa un panic. La sentencia select nunca seleccionará un caso con un canal nil que esté bloqueado.
- Esto permite deshabilitar dinámicamente casos dentro de un select estableciendo el canal a nil, lo cual simplifica la lógica y evita la necesidad de múltiples estructuras select para diferentes escenarios.
- Un select con solo canales nil y sin un caso default se bloquea indefinidamente.
Usos y Patrones Comunes
- Manejo de múltiples eventos: Permite a un programa responder a diferentes tipos de eventos concurrentes, como la recepción de datos, la necesidad de realizar una nueva operación de fetch o una solicitud de cierre.
- Timeouts: Se puede utilizar select junto con la función time.After para implementar timeouts en las comunicaciones, lo que garantiza que una operación no se bloquee indefinidamente si no hay respuesta dentro de un tiempo determinado.
- Cancelación: select es clave para manejar señales de cancelación, permitiendo que una gorutina termine su ejecución de manera controlada cuando ya no se necesita.
- Serialización de acceso al estado mutable: Al estructurar el código con un ciclo for-select donde el estado mutable es propiedad de una única gorutina y se accede a él solo a través de los casos del select, se evitan las condiciones de carrera (data races).
- Patrones de solicitud-respuesta (request-response): Permite implementar pequeños "servidores" internos donde una gorutina escucha solicitudes en un canal y responde en otro canal que se pasa dentro de la solicitud.
- Manejo de operaciones de E/S bloqueantes: Permite ejecutar operaciones de E/S, que pueden tardar mucho tiempo, en una gorutina separada y luego usar select para recibir los resultados sin bloquear la lógica principal.

La versatilidad de los canales y la sentencia select permiten construir software concurrente robusto y receptivo, incluso en sistemas complejos y distribuidos.

Samuel Soto Hoyos

student•

Es importante que la longitud del canal nunca sea mayor a su capacidad*

Mario Andres Martinez Mejia

student•

package main

import (
	"fmt"
	"time"
)

// Creamos 3 funciones
func EstaEnRojo(ch chan string) {
	time.Sleep(2 * time.Second)
	ch <- "🔴"
}

func EstaEnVerde(ch chan string) {
	time.Sleep(2 * time.Second)
	ch <- "🟢"
}

func EstaEnAmarillo(ch chan string) {
	time.Sleep(1 * time.Second)
	ch <- "🟡"
}

func main() {
	//Creamos 3 canales
	Rojo := make(chan string)
	Amarillo := make(chan string)
	Verde := make(chan string)

	for {

		//Comenzamos con Amarillo
		go EstaEnAmarillo(Amarillo)

		select {
		case msg := <-Amarillo:
			fmt.Println("Iniciamos: ", msg)
		}

		// Luego lanzamos Rojo y Verde en paralelo
		go EstaEnRojo(Rojo)
		go EstaEnVerde(Verde)

		select {
		case msg := <-Verde:
			fmt.Println("Gana el paso!", msg)
			fmt.Println("Rojo debe esperar")
			<-Rojo

		case msg := <-Rojo:
			fmt.Println("Ya no pasas!", msg)
			fmt.Println("Verde debe esperar")
			<-Verde
		}

	}
}