Go-Nebenläufigkeit
Nebenläufigkeit ist die Fähigkeit eines Programms, mehrere Aufgaben gleichzeitig auszuführen.
Die Go-Sprache unterstützt Nebenläufigkeit und bietet eine prägnante und effiziente Möglichkeit, sie durch Goroutinen und Kanäle umzusetzen.
Goroutinen:
- Die Einheit der nebenläufigen Ausführung in Go, ähnlich wie leichtgewichtige Threads.
- Das Scheduling von Goroutinen wird von der Go-Runtime verwaltet; Benutzer müssen Threads nicht manuell zuweisen.
- Nutzung
goDas Schlüsselwort startet eine Goroutine. - Goroutinen sind nicht blockierend und können effizient Zehntausende von Goroutinen ausführen.
Channel:
- Der Mechanismus, der für die Kommunikation zwischen Goroutinen in Go verwendet wird.
- Unterstützt Synchronisierung und gemeinsame Datennutzung und vermeidet explizite Sperrmechanismen.
- Nutzung
chanErzeugt durch das Schlüsselwort, über<-Der Operator sendet und empfängt Daten.
Scheduler:
Der Scheduler von Go basiert auf dem GMP-Modell. Der Scheduler weist Goroutinen System-Threads zur Ausführung zu und verwaltet Nebenläufigkeit effizient durch die Koordination von M und P.
- G:Goroutine。
- M: System-Thread (Maschine).
- P: Logischer Prozessor.
Goroutine
Goroutines sind leichtgewichtige Threads, und ihre Zeitplanung wird von der Go-Laufzeit verwaltet.
Goroutine-Syntaxformat:
go 函数名( 参数列表 )
Zum Beispiel:
go f(x, y, z)
Eine neue Goroutine starten:
f(x, y, z)
Go ermöglicht es der go-Anweisung, einen neuen Laufzeit-Thread zu starten, nämlich eine Goroutine, die eine Funktion in einer eigenen, neu erstellten Goroutine ausführt. Alle Goroutines im selben Programm teilen sich denselben Adressraum.
Beispiel
import (
"fmt"
"time"
)
func sayHello() {
for i := 0; i < 5; i++ {
fmt.Println("Hello")
time.Sleep(100 * time.Millisecond)
}
}
func main() {
go sayHello() // Eine Goroutine starten
for i := 0; i < 5; i++ {
fmt.Println("Main")
time.Sleep(100 * time.Millisecond)
}
}
Wenn Sie den obigen Code ausführen, sehen Sie Main und Hello in der Ausgabe. Die Ausgabe hat keine feste Reihenfolge, da sie von zwei Goroutines ausgeführt werden:
Main Hello Main Hello ...
Kanal
Kanäle werden für die Datenübertragung zwischen Goroutinen verwendet.
Kanäle können für synchronisierte Ausführung und Kommunikation zwischen zwei Goroutinen verwendet werden, indem ein Wert eines angegebenen Typs übergeben wird.
NutzungmakeDie Funktion erstellt einen Kanal, unter Verwendung von<-Der Operator <- sendet und empfängt Daten. Wenn keine Richtung angegeben ist, handelt es sich um einen bidirektionalen Kanal.
ch <- v // 把 v 发送到通道 ch
v := <-ch // 从 ch 接收数据
// 并把值赋给 v
Das Deklarieren eines Kanals ist sehr einfach; wir verwenden einfach das Schlüsselwort chan. Ein Kanal muss vor der Verwendung erstellt werden:
ch := make(chan int)
HinweisStandardmäßig sind Kanäle ungepuffert. Wenn der Sender Daten sendet, muss gleichzeitig ein entsprechender Empfänger die Daten empfangen.
Das folgende Beispiel verwendet zwei Goroutinen, um die Summe von Zahlen zu berechnen. Nachdem die Goroutinen ihre Berechnungen abgeschlossen haben, wird die Summe der beiden Ergebnisse berechnet:
Beispiel
import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // Summe an Kanal c senden
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
x, y := <-c, <-c // Von Kanal c empfangen
fmt.Println(x, y, x+y)
}
Das Ausgabeergebnis ist:
-5 17 12
Kanalpuffer
Kanäle können einen Puffer haben, wobei die Puffergröße durch das zweite Argument von make angegeben wird:
ch := make(chan int, 100)
Gepufferte Kanäle ermöglichen es, dass sich das Senden von Daten durch den Sender und das Empfangen von Daten durch den Empfänger in einem asynchronen Zustand befinden. Das heißt, vom Sender gesendete Daten können im Puffer abgelegt werden und darauf warten, dass der Empfänger sie abholt, anstatt dass der Empfänger sie sofort abholen muss.
Da die Puffergröße jedoch begrenzt ist, muss es dennoch einen Empfänger geben, der Daten empfängt. Andernfalls kann der Sender, sobald der Puffer voll ist, keine weiteren Daten senden.
HinweisWenn ein Kanal ungepuffert ist, blockiert der Sender, bis der Empfänger einen Wert vom Kanal empfangen hat. Wenn ein Kanal gepuffert ist, blockiert der Sender, bis der gesendete Wert in den Puffer kopiert wurde; wenn der Puffer voll ist, bedeutet das Warten, bis ein Empfänger einen Wert abholt. Der Empfänger blockiert, bis ein Wert zum Empfangen vorhanden ist.
Beispiel
import "fmt"
func main() {
// Hier definieren wir einen gepufferten Kanal, der Ganzzahlen speichern kann
// Die Puffergröße ist 2
ch := make(chan int, 2)
// Da ch ein gepufferter Kanal ist, können wir zwei Werte gleichzeitig senden
// ohne dass Daten sofort synchron gelesen werden müssen
ch <- 1
ch <- 2
// Diese beiden Werte empfangen
fmt.Println(<-ch)
fmt.Println(<-ch)
}
Die Ausgabe der Ausführung ist:
1 2
Go: Über Kanäle mit range iterieren und Kanäle schließen
Go verwendet das Schlüsselwort range, um über empfangene Daten zu iterieren, ähnlich wie bei Arrays oder Slices. Das Format ist wie folgt:
v, ok := <-ch
Wenn der Kanal keine Daten empfängt, wird ok false, und dann kann der Kanal mit close() geschlossen werden.close()-Funktion zum Schließen.
Beispiel
import (
"fmt"
)
func fibonacci(n int, c chan int) {
x, y := 0, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
// Die range-Funktion iteriert über jeden vom Kanal empfangenen Wert, denn nachdem c 10
// Werte gesendet hat, schließt sie den Kanal, also hier die range-Funktion, nach dem Empfang von 10 Werten
// dann endet. Wenn der obige c-Kanal nicht geschlossen ist, dann wird die range-Funktion nicht
// enden, und somit blockiert sie beim Empfang des 11. Wertes.
for i := range c {
fmt.Println(i)
}
}
Die Ausgabe der Ausführung ist:
0 1 1 2 3 5 8 13 21 34
Select-Anweisung
selectDie select-Anweisung ermöglicht es einer Goroutine, auf mehrere Kommunikationsoperationen zu warten.selectEs blockiert, bis einer seiner Fälle fortgesetzt werden kann:
Beispiel
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
Im obigen Code,fibonacciGoroutine auf einem KanalcSende die Fibonacci-Folge weiter, und beim EmpfangenquitBeenden, wenn ein Signal vom Kanal empfangen wird.
Die Ausgabe der Ausführung ist:
0 1 1 2 3 5 8 13 21 34 quit
Verwendung von WaitGroup
sync.WaitGroup wird verwendet, um auf den Abschluss mehrerer Goroutinen zu warten.
Mehrere Goroutinen synchronisieren:
Beispiel
import (
"fmt"
"sync"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // Done() aufrufen, wenn die Goroutine abgeschlossen ist
fmt.Printf("Worker %d gestartet\n", id)
fmt.Printf("Worker %d beendet\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
wg.Add(1) // Zähler erhöhen
go worker(i, &wg)
}
wg.Wait() // Warten, bis alle Goroutinen abgeschlossen sind
fmt.Println("Alle Worker fertig")
}
Für den obigen Code sieht die Ausführungsausgabe wie folgt aus:
Worker 1 started Worker 1 finished Worker 2 started Worker 2 finished Worker 3 started Worker 3 finished All workers done
Erweiterte Funktionen
Gepufferter Channel:
Erstelle einen gepufferten Channel.
ch := make(chan int, 2)
Kontext:
Wird verwendet, um den Lebenszyklus von Goroutines zu steuern.
context.WithCancel、context.WithTimeout。
Mutex und RWMutex:
sync.Mutex bietet eine Sperre für gegenseitigen Ausschluss zum Schutz gemeinsam genutzter Ressourcen.
var mu sync.Mutex mu.Lock() // critical section mu.Unlock()
Zusammenfassung der nebenläufigen Programmierung
Die Sprache Go bietet leistungsstarke Nebenläufigkeitsunterstützung durch Goroutines und Channels und vereinfacht die Komplexität des traditionellen Threading-Modells. Mit dem Scheduler und Synchronisierungswerkzeugen können hochperformante nebenläufige Programme einfach implementiert werden.
- GoroutinesSind leichtgewichtige Threads, unter Verwendung von
goGestartet durch das Schlüsselwort. - ChannelsDienen der Kommunikation zwischen Goroutines.
- Select-AnweisungWird verwendet, um auf mehrere Channel-Operationen zu warten.
FAQ
Deadlock:
- Beispiel: Alle Goroutinen warten, aber es sind keine Daten verfügbar.
- Lösung: Vermeiden Sie unendliches Warten und schließen Sie Channels ordnungsgemäß.
Datenrennen:
- Beispiel: Mehrere Goroutinen greifen gleichzeitig auf dieselbe Variable zu.
- Lösung: Verwenden Sie Mutex oder Channel, um den Zugriff zu synchronisieren.