[Golang] Über Go-Sprache Produzent und Konsument

Heute habe ich von Go's Producer and Consumer erfahren, also werde ich darüber berichten.

Vorausgesetztes Wissen

• Grundlegende Grammatik von Go --Kanal
• Goroutine

Ich denke, dieser Artikel wird leichter zu verstehen sein, wenn Sie etwas darüber wissen. Wenn Sie nicht verstehen, habe ich auch einen Artikel über Kanäle und Goroutine geschrieben. Bitte lesen Sie ihn, wenn Sie möchten! [Golang] Über den Go-Sprachkanal [Golang] Go Sprachgrundlagen Was ist Goroutine?

Was sind Produzent und Konsument?

Bitte sehen Sie zunächst die folgende Abbildung.

Der Ablauf ist so, dass das Verarbeitungsergebnis der Parallelverarbeitung (Producer), die von func main ausgeführt wird, an den Kanal gesendet wird und der gesendete Wert von Consumer verarbeitet wird. Insbesondere scheint es verwendet zu werden, indem man zu verschiedenen Servern geht, das Protokoll analysiert, das Ergebnis auf dem Kanal (Produzent) sendet, den Wert des gesendeten Kanals auf dem Verbraucher empfängt und verarbeitet!

Sie können es nicht allein mit Worten verstehen, also schreiben wir den Code tatsächlich.

package main

import (
	"fmt"
	"sync"
)

func producer(ch chan int, i int) {
	//Einige Verarbeitung
	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)
}

**Ausführungsergebnis**
process 0
process 400
process 200
process 600
process 800
process 1000
process 1200
process 1400
process 1600
process 1800

Erstellen Sie zunächst eine wg-Variable und einen Kanal und speichern Sie sie in der ch-Variablen. Jetzt generiere ** Produzent **. Die Anzahl der parallelen Prozesse wird durch Setzen von wg.Add (1) erhöht. (Ich sage wg, dass es 10 parallele Prozesse gibt, weil ich hier 10 Mal schleife) Übergeben Sie dann ch und i als Argumente an die ** Producer-Funktion ** und fügen Sie eine go-Anweisung hinzu, um die parallele Verarbeitung auszuführen.

Die ** Producer-Funktion ** macht etwas und sendet das ** i * 2 ** an den Kanal. Wenn die Verarbeitung abgeschlossen ist, übergeben Sie die Adressen von ch und wg an die ** Consumer-Funktion **. Die ** Consumer-Funktion ** nimmt den von der ** Producer-Funktion ** gesendeten Kanalwert heraus und schleift ihn mit dem Bereich. Der Inhalt der Schleifenverarbeitung gibt i * 1000 aus, und wg.Done teilt mit, dass diese Verarbeitung abgeschlossen ist. Dies wird 10 Mal wiederholt.

Wenn dies erledigt ist, gehen Sie zu wg.Wait (hier warten Sie, bis der Vorgang 10 Mal abgeschlossen ist) ** Schließen (ch), um zu beschreiben, dass der Kanal geschlossen ist. ** ** **

Als Einschränkung ist ** Consumer selbst Goroutine. Selbst nach zehnmaliger Verarbeitung versucht er immer noch, den Wert vom Kanal abzurufen, und wartet darauf, dass der Kanal von der Producer-Funktion gesendet wird, um den Bereich zu ändern. Ich werde. ** ** ** Sie können sehen, dass die Producer-Funktion den Wert 10 Mal an den Kanal sendet, die Consumer-Funktion jedoch nicht weiß, dass 10 Werte gesendet werden. Es wird versucht, den nächsten Wert zu durchlaufen, es sei denn, es signalisiert das Ende des Kanals. Wie gesund! .. Daher muss beschrieben werden, dass der Kanal geschlossen ist, indem "close (ch)" gesetzt wird, dass "der Wert nicht mehr von der Produzentenfunktion gesendet wird"!

Vielen Dank für das Lesen bis zum Ende!

Ich hoffe, dieser Artikel hat Ihnen geholfen zu verstehen! Wir würden uns freuen, wenn Sie Ihre Eindrücke und Vorschläge kommentieren könnten!