Channels y comunicación

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy — lección 60 de 107.

Los canales son el mecanismo principal de Go para la comunicación entre goroutines. En lugar de compartir memoria directamente, las goroutines envían y reciben valores a través de canales, siguiendo la filosofía de Go: "No te comuniques compartiendo memoria; comparte memoria comunicándote".

Crea un canal usando la función make con la palabra clave chan:

messages := make(chan string)

Usa el operador de flecha <- para enviar y recibir valores. La flecha apunta en la dirección del flujo de datos:

func main() {
    messages := make(chan string)
    
    go func() {
        messages <- "hello"  // enviar al canal
    }()
    
    msg := <-messages  // recibir del canal
    fmt.Println(msg)   // Salida: hello
}

Por defecto, los envíos y recepciones se bloquean hasta que el otro lado esté listo. Cuando la goroutine envía "hello", espera hasta que main esté listo para recibir. Este comportamiento de bloqueo proporciona sincronización integrada; no se necesita time.Sleep.

Puedes cerrar un canal para indicar que no se enviarán más valores. Los receptores pueden detectar esto:

close(messages)

msg, ok := <-messages
if !ok {
    fmt.Println("Channel closed")
}

Los canales son tipados: un chan string solo puede transportar cadenas. Esta seguridad de tipos garantiza que las goroutines se comuniquen con los tipos de datos correctos, detectando errores en tiempo de compilación en lugar de en tiempo de ejecución.

Desafío

Fácil

Vamos a construir un sistema de retransmisión de mensajes que demuestre cómo las goroutines se comunican a través de canales. Crearás un pipeline donde los mensajes fluyen entre diferentes etapas de procesamiento, con cada etapa ejecutándose de forma concurrente.

Organizarás tu código en dos archivos:

relay.go: Define tu pipeline de procesamiento de mensajes.
Crea un struct Message con los campos ID (int) y Content (string).

Implementa tres funciones que representen diferentes etapas de tu pipeline:
- Producer(messages []Message, out chan Message) - Toma un slice de mensajes y envía cada uno al canal de salida. Después de enviar todos los mensajes, cierra el canal para señalar la finalización.
- Transformer(in chan Message, out chan Message) - Recibe mensajes del canal de entrada, transforma el contenido de cada mensaje a mayúsculas y envía el mensaje transformado al canal de salida. Cuando el canal de entrada se cierre (detectado usando la forma de recepción de dos valores), cierra el canal de salida.
- Consumer(in chan Message) []string - Recibe todos los mensajes del canal de entrada y los recolecta en un slice de strings formateados. Cada string debe seguir el formato: "Message %d: %s". Devuelve el slice cuando el canal se cierre.
main.go: Configura el pipeline y orquestar el flujo de mensajes concurrente.
Lee el número de mensajes, luego lee el ID y el contenido de cada mensaje. Crea los mensajes y configura dos canales para conectar tus tres etapas del pipeline. Lanza el Producer y el Transformer como goroutines, luego ejecuta el Consumer en la goroutine principal para recolectar los resultados. Imprime cada resultado en una línea separada.

Se proporcionarán las siguientes entradas:

Línea 1: Número de mensajes (entero)
Líneas siguientes: Para cada mensaje, dos líneas - el ID del mensaje (entero), luego su contenido (string)

Por ejemplo, dado:

2
1
hello world
2
go channels

Tu salida debería ser:

Message 1: HELLO WORLD
Message 2: GO CHANNELS

El pipeline fluye así: Producer envía mensajes → Transformer los convierte a mayúsculas → Consumer recolecta y formatea los resultados. Cada flecha representa un canal que conecta etapas concurrentes. Utiliza el paquete strings para la transformación a mayúsculas.

Hoja de referencia

Los canales son el mecanismo principal de Go para la comunicación entre goroutines. Crea un canal usando make con la palabra clave chan:

messages := make(chan string)

Usa el operador de flecha <- para enviar y recibir valores. La flecha apunta en la dirección del flujo de datos:

messages <- "hello"  // send to channel
msg := <-messages    // receive from channel

Por defecto, los envíos y recepciones se bloquean hasta que el otro lado esté listo, proporcionando sincronización integrada:

func main() {
    messages := make(chan string)
    
    go func() {
        messages <- "hello"  // send to channel
    }()
    
    msg := <-messages  // receive from channel
    fmt.Println(msg)   // Output: hello
}

Cierra un canal para indicar que no se enviarán más valores. Los receptores pueden detectar el cierre utilizando la forma de recepción de dos valores:

close(messages)

msg, ok := <-messages
if !ok {
    fmt.Println("Channel closed")
}

Los canales tienen tipos: un chan string solo puede transportar cadenas, lo que proporciona seguridad de tipos en tiempo de compilación.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Leer el número de mensajes
	nLine, _ := reader.ReadString('\n')
	n, _ := strconv.Atoi(strings.TrimSpace(nLine))

	// Leer mensajes
	messages := make([]Message, n)
	for i := 0; i < n; i++ {
		idLine, _ := reader.ReadString('\n')
		id, _ := strconv.Atoi(strings.TrimSpace(idLine))
		contentLine, _ := reader.ReadString('\n')
		content := strings.TrimSpace(contentLine)
		messages[i] = Message{ID: id, Content: content}
	}

	// TODO: Crear dos canales para conectar las etapas del pipeline

	// TODO: Lanzar Producer como una goroutine

	// TODO: Lanzar Transformer como una goroutine

	// TODO: Ejecutar Consumer en la goroutine principal y recolectar resultados

	// TODO: Imprimir cada resultado en una línea separada
}