[Golang] À propos du producteur et consommateur de langue Go

Aujourd'hui, j'ai découvert le producteur et le consommateur de Go, alors je vais en sortir.

Connaissances préalables

• Grammaire de base de Go --Canal
• Goroutine

Je pense que cet article sera plus facile à comprendre si vous avez des connaissances à ce sujet. Si vous ne comprenez pas, j'ai également écrit un article sur les chaînes et Goroutine, alors veuillez vous y référer si vous le souhaitez! [Golang] À propos de la chaîne linguistique Go [Golang] Go Bases de la langue Qu'est-ce que Goroutine?

Que sont le producteur et le consommateur?

Tout d'abord, veuillez consulter la figure ci-dessous.

Le flux est que le résultat du traitement du traitement parallèle (Producer) exécuté à partir de func main est envoyé au canal et la valeur envoyée est traitée par Consumer. Plus précisément, il semble être utilisé en allant sur différents serveurs, en analysant le journal, en envoyant le résultat sur le canal (Producer), en recevant la valeur du canal envoyé sur le consommateur, et en le traitant!

Vous ne pouvez pas le comprendre uniquement à partir de mots, alors écrivons le code.

package main

import (
	"fmt"
	"sync"
)

func producer(ch chan int, i int) {
	//Certains traitements
	ch <- i * 2
}

func consumer(ch chan int, wg *sync.WaitGroup) {
	for i := range ch {
		fmt.Println("process", i*100)
		wg.Done()
	}
}

func main() {
	var wg sync.WaitGroup
	ch := make(chan int)

	//Producer
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go producer(ch, i)
	}

	//Consumer
	go consumer(ch, &wg)
	wg.Wait()
	close(ch)
}

**Résultat d'exécution**
process 0
process 400
process 200
process 600
process 800
process 1000
process 1200
process 1400
process 1600
process 1800

Tout d'abord, créez une variable wg et un canal et stockez-les dans la variable ch. Générez maintenant ** Producer **. Le nombre de processus parallèles est incrémenté en définissant wg.Add (1). (Je dis à wg qu'il y a 10 processus parallèles car je boucle 10 fois ici) Ensuite, passez ch et i comme arguments à la ** fonction de producteur ** et attachez une instruction go pour exécuter le traitement parallèle.

La ** fonction de producteur ** fait quelque chose et envoie le ** i * 2 ** au canal. Ensuite, lorsque le traitement est terminé, transmettez les adresses de ch et wg à la ** fonction consommateur **. La ** fonction consommateur ** prend la valeur de canal envoyée par la ** fonction producteur ** et la boucle avec la plage. Le contenu du traitement en boucle sort i * 1000, et wg.Done indique que ce traitement est terminé. Ceci est répété 10 fois.

Lorsque cela est fait, allez à wg.Wait (ici, attendez que le processus soit terminé 10 fois) ** Close (ch) pour décrire que le canal est fermé. ** **

En guise d'avertissement ici, ** le consommateur lui-même est Goroutine, donc même après 10 fois de traitement, il essaie toujours d'obtenir la valeur du canal, en attendant que le canal soit envoyé par la fonction de producteur pour tourner la plage. Je vais. ** ** Vous pouvez voir que la fonction producteur envoie la valeur au canal 10 fois, mais la fonction consommateur ne sait pas que 10 valeurs sont envoyées. Il essaiera de parcourir la valeur suivante à moins qu'il ne signale la fin du canal. Comme c'est sain d'esprit! .. Par conséquent, il est nécessaire de décrire que le canal est fermé en réglant "close (ch)" que "Plus aucune valeur ne sera envoyée par la fonction producteur"!

Merci d'avoir lu jusqu'au bout!

J'espère que cet article vous a aidé à comprendre! Nous vous serions reconnaissants de bien vouloir commenter vos impressions et suggestions!