Canais com e sem buffer

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy. Lição 61 de 107.

Os canais que usamos até agora são sem buffer. Eles não têm capacidade para armazenar valores. Uma operação de envio é bloqueada até que outra goroutine receba, e vice-versa. Os canais com buffer adicionam armazenamento interno, permitindo que os envios sejam concluídos sem um receptor imediato.

Crie um canal com buffer passando uma capacidade para make:

// Não bufferizado - capacidade 0
unbuffered := make(chan int)

// Bufferizado - capacidade 3
buffered := make(chan int, 3)

Com um canal com buffer, os envios só bloqueiam quando o buffer está cheio, e os recebimentos só bloqueiam quando o buffer está vazio:

ch := make(chan string, 2)

ch <- "first"   // não bloqueia - o buffer tem espaço
ch <- "second"  // não bloqueia - o buffer tem espaço
// ch <- "third" bloquearia - o buffer está cheio

fmt.Println(<-ch)  // "first"
fmt.Println(<-ch)  // "second"

Use len(ch) para verificar quantos itens estão atualmente no buffer e cap(ch) para a capacidade total.

Quando usar cada um: Os canais sem buffer fornecem uma sincronização rigorosa: o remetente sabe que o receptor recebeu o valor. Os canais com buffer desacoplam o tempo do remetente e do receptor, sendo úteis quando produtores e consumidores trabalham em velocidades diferentes. No entanto, os canais com buffer podem mascarar bugs de sincronização; portanto, prefira canais sem buffer, a menos que tenha um motivo específico para usar buffer.

Desafio

Fácil

Vamos criar um processador em lote que demonstra a diferença entre canais com buffer e sem buffer. Você criará um sistema no qual um produtor envia itens para um processador, usando canais com buffer para desacoplar o tempo de execução deles e permitir que o produtor avance.

Você organizará seu código em dois arquivos:

processor.go: Defina a lógica de processamento em lote usando canais.
Crie uma struct Item com campos ID (int) e Value (string).

Implemente duas funções:
- Producer(items []Item, out chan Item) - Envia cada item para o canal de saída. Depois de enviar cada item, imprima: Produced item [ID]. Depois que todos os itens forem enviados, imprima o número atual de itens aguardando no buffer usando len(out) no formato: Buffer has [count] items. Em seguida, feche o canal.
- Consumer(in chan Item) []string - Recebe itens do canal de entrada e os coleta em um slice de strings formatadas. Para cada item recebido, a string deve ser: Consumed: [ID] - [Value]. Retorne o slice quando o canal for fechado.
main.go: Configure o canal com buffer e coordene o produtor e o consumidor.
Leia a capacidade do buffer, depois o número de itens, seguido pelo ID e pelo valor de cada item. Crie um canal com buffer com a capacidade especificada. Execute o Producer primeiro (não como uma goroutine) para preencher o buffer e, em seguida, execute o Consumer para processar todos os itens. Imprima cada resultado consumido em uma linha separada.

As entradas a seguir serão fornecidas:

Linha 1: Capacidade do buffer (inteiro)
Linha 2: Número de itens (inteiro)
Linhas seguintes: Para cada item, duas linhas — o ID do item (inteiro) e, depois, seu valor (string)

Por exemplo, dada a entrada:

3
3
1
apple
2
banana
3
cherry

Sua saída deve ser:

Produced item 1
Produced item 2
Produced item 3
Buffer has 3 items
Consumed: 1 - apple
Consumed: 2 - banana
Consumed: 3 - cherry

Observe como, com uma capacidade de buffer de 3, o produtor pode enviar todos os 3 itens sem bloquear, e o buffer mostra 3 itens aguardando antes de o consumidor iniciar. Se o buffer fosse menor que o número de itens, o produtor bloquearia esperando por espaço.

Experimente você mesmo

package main

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

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

	// Ler a capacidade do buffer
	line, _ := reader.ReadString('\n')
	bufferCapacity, _ := strconv.Atoi(strings.TrimSpace(line))

	// Ler o número de itens
	line, _ = reader.ReadString('\n')
	numItems, _ := strconv.Atoi(strings.TrimSpace(line))

	// Ler o ID e o valor de cada item
	items := make([]Item, numItems)
	for i := 0; i < numItems; i++ {
		line, _ = reader.ReadString('\n')
		id, _ := strconv.Atoi(strings.TrimSpace(line))
		line, _ = reader.ReadString('\n')
		value := strings.TrimSpace(line)
		items[i] = Item{ID: id, Value: value}
	}

	// TODO: Criar um canal com buffer com a capacidade especificada

	// TODO: Executar o Producer (não como uma goroutine) para preencher o buffer

	// TODO: Executar o Consumer para processar todos os itens

	// TODO: Imprimir cada resultado consumido em uma linha separada
}