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
}

De forma predeterminada, los envíos y las recepciones se bloquean hasta que el otro lado está listo. Cuando la gorutina envía "hello", espera hasta que main esté lista 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 detectarlo:

close(messages)

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

Los canales están 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 los errores en tiempo de compilación en lugar de en tiempo de ejecución.

Desafío

Fácil

Construyamos un sistema de retransmisión de mensajes que demuestre cómo las goroutines se comunican a través de canales. Crearás una canalización en la que los mensajes fluyen entre diferentes etapas de procesamiento, mientras cada etapa se ejecuta de forma concurrente.

Organizarás tu código en dos archivos:

relay.go: Define tu canalización de procesamiento de mensajes.
Crea una estructura Message con campos ID (int) y Content (string).

Implementa tres funciones que representen diferentes etapas de tu canalización:
- Producer(messages []Message, out chan Message) - Recibe un slice de mensajes y envía cada uno al canal de salida. Después de enviar todos los mensajes, cierra el canal para indicar que se ha completado.
- 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 se cierra el canal de entrada (detectado mediante 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 recopila en un slice de cadenas formateadas. Cada cadena debe seguir el formato: Message [ID]: [Content]. Devuelve el slice cuando se cierra el canal.
main.go: Configura la canalización y coordina el flujo concurrente de mensajes.
Lee el número de mensajes y, después, lee el ID y el contenido de cada mensaje. Crea los mensajes y configura dos canales para conectar las tres etapas de la canalización. Inicia Producer y Transformer como goroutines y, después, ejecuta Consumer en la goroutine principal para recopilar los resultados. Imprime cada resultado en una línea independiente.

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) y después su contenido (cadena)

Por ejemplo, dada la siguiente entrada:

2
1
hello world
2
go channels

Tu salida debería ser:

Message 1: HELLO WORLD
Message 2: GO CHANNELS

La canalización funciona así: Producer envía mensajes → Transformer los convierte a mayúsculas → Consumer recopila y formatea los resultados. Cada flecha representa un canal que conecta etapas concurrentes. Usa el paquete strings para la transformación a mayúsculas.

Pruébalo tú mismo

package main

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

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

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

	// Lee los 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: Crea dos canales para conectar las etapas del pipeline

	// TODO: Lanza Producer como una goroutine

	// TODO: Lanza Transformer como una goroutine

	// TODO: Ejecuta Consumer en la goroutine principal y recoge los resultados

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