Channels avec buffer vs sans buffer

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 61 sur 107.

Les canaux que nous avons utilisés jusqu'à présent sont non tamponnés — ils n'ont aucune capacité pour contenir des valeurs. Une opération d'envoi bloque jusqu'à ce qu'une autre goroutine reçoive, et vice versa. Les canaux tamponnés ajoutent un stockage interne, permettant aux envois de se terminer sans récepteur immédiat.

Créez un canal tamponné en passant une capacité à make :

// Non tamponné - capacité 0
unbuffered := make(chan int)

// Tamponné - capacité 3
buffered := make(chan int, 3)

Avec un canal avec tampon, les envois ne bloquent que lorsque le tampon est plein, et les réceptions ne bloquent que lorsque le tampon est vide :

ch := make(chan string, 2)

ch <- "first"   // ne bloque pas - le tampon a de l'espace
ch <- "second"  // ne bloque pas - le tampon a de l'espace
// ch <- "third" bloquerait - le tampon est plein

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

Utilisez len(ch) pour vérifier combien d'éléments se trouvent actuellement dans le tampon, et cap(ch) pour la capacité totale.

Quand utiliser chacun : Les canaux non tamponnés offrent une synchronisation étroite — l'expéditeur sait que le destinataire a reçu la valeur. Les canaux tamponnés découplent le timing de l'expéditeur et du destinataire, ce qui est utile lorsque les producteurs et les consommateurs travaillent à des vitesses différentes. Cependant, les canaux tamponnés peuvent masquer des bogues de synchronisation, privilégiez donc les canaux non tamponnés à moins d'avoir une raison spécifique pour le tamponnage.

Défi

Facile

Construisons un processeur par lots qui démontre la différence entre les canaux avec tampon (buffered) et sans tampon (unbuffered). Vous allez créer un système où un producteur envoie des éléments à un processeur, en utilisant des canaux avec tampon pour découpler leur timing et permettre au producteur de prendre de l'avance.

Vous organiserez votre code sur deux fichiers :

processor.go : Définissez votre logique de traitement par lots en utilisant des canaux.
Créez une structure Item avec les champs ID (int) et Value (string).

Implémentez deux fonctions :
- Producer(items []Item, out chan Item) - Envoie chaque élément vers le canal de sortie. Après avoir envoyé chaque élément, affichez : Produced item [ID]. Une fois que tous les éléments sont envoyés, affichez le nombre actuel d'éléments en attente dans le tampon en utilisant len(out) au format : Buffer has [count] items. Ensuite, fermez le canal.
- Consumer(in chan Item) []string - Reçoit les éléments du canal d'entrée et les collecte dans une tranche (slice) de chaînes de caractères formatées. Pour chaque élément reçu, la chaîne doit être : Consumed: [ID] - [Value]. Retournez la tranche lorsque le canal est fermé.
main.go : Configurez le canal avec tampon et coordonnez le producteur et le consommateur.
Lisez la capacité du tampon, puis le nombre d'éléments, suivis de l'ID et de la valeur de chaque élément. Créez un canal avec tampon avec la capacité spécifiée. Exécutez d'abord le Producer (pas en tant que goroutine) pour remplir le tampon, puis exécutez le Consumer pour traiter tous les éléments. Affichez chaque résultat consommé sur une ligne distincte.

Les entrées suivantes seront fournies :

Ligne 1 : Capacité du tampon (entier)
Ligne 2 : Nombre d'éléments (entier)
Lignes suivantes : Pour chaque élément, deux lignes - l'ID de l'élément (entier), puis sa valeur (chaîne de caractères)

Par exemple, avec :

3
3
1
apple
2
banana
3
cherry

Votre sortie devrait être :

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

Remarquez comment, avec une capacité de tampon de 3, le producteur peut envoyer les 3 éléments sans bloquer, et le tampon affiche 3 éléments en attente avant que le consommateur ne commence. Si le tampon était plus petit que le nombre d'éléments, le producteur bloquerait en attendant de l'espace.

Aide-mémoire

Les canaux (channels) en Go peuvent être non tamponnés (capacité 0) ou tamponnés (avec un stockage interne).

Créez des canaux avec make :

// Unbuffered - capacity 0
unbuffered := make(chan int)

// Buffered - capacity 3
buffered := make(chan int, 3)

Comportement des canaux tamponnés :

Les envois ne bloquent que lorsque le tampon est plein
Les réceptions ne bloquent que lorsque le tampon est vide

ch := make(chan string, 2)

ch <- "first"   // doesn't block - buffer has space
ch <- "second"  // doesn't block - buffer has space
// ch <- "third" would block - buffer is full

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

Vérifier l'état du tampon :

len(ch) - nombre d'éléments actuellement dans le tampon
cap(ch) - capacité totale du tampon

Quand les utiliser :

Non tamponnés : Synchronisation étroite — l'expéditeur sait que le récepteur a reçu la valeur
Tamponnés : Découpler le timing de l'expéditeur et du récepteur lorsqu'ils travaillent à des vitesses différentes

Essayez vous-même

package main

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

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

	// Lire la capacité du tampon
	line, _ := reader.ReadString('\n')
	bufferCapacity, _ := strconv.Atoi(strings.TrimSpace(line))

	// Lire le nombre d'éléments
	line, _ = reader.ReadString('\n')
	numItems, _ := strconv.Atoi(strings.TrimSpace(line))

	// Lire l'ID et la valeur de chaque élément
	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: Créer un canal tamponné (buffered channel) avec la capacité spécifiée

	// TODO: Exécuter le Producer (pas en tant que goroutine) pour remplir le tampon

	// TODO: Exécuter le Consumer pour traiter tous les éléments

	// TODO: Afficher chaque résultat consommé sur une ligne distincte
}