Canaux tamponnés ou non tamponnés

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 stocker des valeurs. Une opération d’envoi se bloque jusqu’à ce qu’une autre goroutine reçoive une valeur, et inversement. Les canaux tamponnés ajoutent un stockage interne, ce qui permet aux envois de se terminer sans récepteur immédiat.

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

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

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

Avec un canal mis en mémoire tampon, les envois ne sont bloqués que lorsque le tampon est plein, et les réceptions ne sont bloquées que lorsque le tampon est vide :

ch := make(chan string, 2)

ch <- "first"   // ne bloque pas - le buffer a de l'espace
ch <- "second"  // ne bloque pas - le buffer a de l'espace
// ch <- "third" bloquerait - le buffer 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 d’eux : Les canaux non tamponnés fournissent une synchronisation étroite : l’expéditeur sait que le récepteur a reçu la valeur. Les canaux tamponnés découplent le rythme de l’expéditeur et du récepteur, ce qui est utile lorsque les producteurs et les consommateurs travaillent à des vitesses différentes. Cependant, les canaux tamponnés peuvent masquer des erreurs de synchronisation ; préférez donc les canaux non tamponnés, sauf si vous avez une raison précise d’utiliser un tampon.

Défi

Facile

Construisons un processeur par lots qui illustre la différence entre les canaux avec tampon et sans tampon. Vous allez créer un système dans lequel un producteur envoie des éléments à un processeur, en utilisant des canaux avec tampon pour découpler leur rythme 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 à l’aide de 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 au canal de sortie. Après l’envoi de chaque élément, affichez : Produced item [ID]. Une fois tous les éléments envoyés, affichez le nombre actuel d’éléments en attente dans le tampon en utilisant len(out), au format : Buffer has [count] items. Fermez ensuite le canal.
- Consumer(in chan Item) []string - Reçoit les éléments du canal d’entrée et les rassemble dans une tranche de chaînes 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, suivi 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 producteur (pas en tant que goroutine) pour remplir le tampon, puis exécutez le consommateur afin de 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)

Par exemple, avec :

3
3
1
apple
2
banana
3
cherry

Votre sortie doit être :

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

Remarquez qu’avec une capacité de tampon de 3, le producteur peut envoyer les 3 éléments sans être bloqué, et que le tampon contient 3 éléments en attente avant le démarrage du consommateur. Si le tampon était plus petit que le nombre d’éléments, le producteur serait bloqué en attendant de la place.

Essayez vous-même

package main

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

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

	// Lire la capacité du buffer
	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 bufferisé avec la capacité spécifiée

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

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

	// TODO: Afficher chaque résultat consommé sur une ligne séparée
}