Go's Concurrency Decoded: Goroutine Scheduling

Ich. Goroutinen: Ein tiefer Einblick in das Parallelitätsmodell von Go

Goroutinen sind ein Eckpfeiler des Go-Designs und bieten einen leistungsstarken Mechanismus für die gleichzeitige Programmierung. Als leichtgewichtige Coroutinen vereinfachen sie die parallele Aufgabenausführung. Das Starten einer Goroutine ist unkompliziert: Stellen Sie einem Funktionsaufruf einfach das Schlüsselwort go voran und starten Sie so die asynchrone Ausführung. Das Hauptprogramm wird fortgesetzt, ohne auf den Abschluss der Goroutine zu warten.

go func() { // Launch a goroutine using the 'go' keyword
    // ... code to be executed concurrently ...
}()

II. Die internen Mechanismen von Goroutine verstehen

Konzeptionelle Grundlagen

Parallelität vs. Parallelität

• Parallelität: Die Fähigkeit, mehrere Aufgaben scheinbar gleichzeitig auf einer einzigen CPU zu verwalten. Die CPU wechselt schnell zwischen Aufgaben, wodurch die Illusion einer parallelen Ausführung entsteht. Während es mikroskopisch sequentiell ist, erscheint es makroskopisch gleichzeitig.

• Parallelität: Echte gleichzeitige Ausführung mehrerer Aufgaben auf mehreren CPUs, wodurch CPU-Ressourcenkonflikte vermieden werden.

Prozesse und Threads

• Prozess: Eine eigenständige Ausführungsumgebung mit eigenen Ressourcen (Speicher, Dateien usw.). Das Wechseln zwischen Prozessen ist ressourcenintensiv und erfordert einen Eingriff auf Kernel-Ebene.

• Thread: Eine leichte Ausführungseinheit innerhalb eines Prozesses, die die Ressourcen des Prozesses gemeinsam nutzt. Der Threadwechsel verursacht weniger Aufwand als der Prozesswechsel.

Koroutinen

Coroutinen verwalten ihren eigenen Registerkontext und Stapel. Das Wechseln zwischen Coroutinen erfordert das Speichern und Wiederherstellen dieses Zustands, sodass sie die Ausführung an der Stelle fortsetzen können, an der sie aufgehört haben. Im Gegensatz zu Prozessen und Threads erfolgt die Verwaltung von Coroutinen innerhalb des Benutzerprogramms und nicht im Betriebssystem. Goroutinen sind eine spezielle Art von Coroutine.

Das GPM-Planungsmodell

Gos effiziente Parallelität basiert auf dem GPM-Planungsmodell. Vier Schlüsselkomponenten sind beteiligt: ​​M, P, G und Sched (Sched ist in den Diagrammen nicht dargestellt).

• M (Maschine): Ein Thread auf Kernel-Ebene. Goroutinen laufen auf Ms.

• G (Goroutine): Eine einzelne Goroutine. Jedes G verfügt über seinen eigenen Stapel, Befehlszeiger und andere planungsbezogene Informationen (z. B. Kanäle, auf die es wartet).

• P (Prozessor): Ein logischer Prozessor, der Goroutinen verwaltet und ausführt. Es unterhält eine Ausführungswarteschlange bereiter Goroutinen.

• Sched (Scheduler): Der zentrale Planer, der M- und G-Warteschlangen verwaltet und eine effiziente Ressourcenzuweisung gewährleistet.

Planung in Aktion

Das Diagramm zeigt zwei Betriebssystem-Threads (M), jeweils mit einem Prozessor (P), der eine Goroutine ausführt.

• GOMAXPROCS() steuert die Anzahl der Ps (und damit den wahren Grad der Parallelität).

• Die grauen Gs sind fertig, laufen aber noch nicht. P verwaltet diese Ausführungswarteschlange.

• Durch das Starten einer Goroutine wird diese zur Ausführungswarteschlange von P hinzugefügt.

Wenn ein M0 blockiert ist, wechselt P zu M1 (der möglicherweise aus einem Thread-Cache abgerufen wird).

Wenn ein P seine Aufgaben schnell erledigt, könnte er anderen Ps Arbeit stehlen, um die Effizienz aufrechtzuerhalten.

III. Arbeiten mit Goroutinen

Grundlegende Verwendung

Legen Sie die Anzahl der CPUs für die Goroutine-Ausführung fest (die Standardeinstellung in neueren Go-Versionen ist normalerweise ausreichend):

go func() { // Launch a goroutine using the 'go' keyword
    // ... code to be executed concurrently ...
}()

Praxisbeispiele

Beispiel 1: Einfache Goroutine-Berechnung

num := runtime.NumCPU() // Get the number of logical CPUs
runtime.GOMAXPROCS(num) // Set the maximum number of concurrently running goroutines

Goroutine-Fehlerbehandlung

Unbehandelte Ausnahmen in einer Goroutine können das gesamte Programm beenden. Verwenden Sie recover() innerhalb einer defer-Anweisung, um mit Paniken umzugehen:

package main

import (
    "fmt"
    "runtime"
)

func cal(a, b int) {
    c := a + b
    fmt.Printf("%d + %d = %d\n", a, b, c)
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    for i := 0; i < 10; i++ {
        go cal(i, i+1)
    }
    //Note:  The main function exits before goroutines complete in this example.  See later sections for synchronization.
}

Goroutinen synchronisieren

Da Goroutinen asynchron laufen, wird das Hauptprogramm möglicherweise beendet, bevor sie abgeschlossen sind. Verwenden Sie sync.WaitGroup oder Kanäle zur Synchronisierung:

Beispiel 1: Verwendung von sync.WaitGroup

package main

import (
    "fmt"
)

func addele(a []int, i int) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Error in addele:", r)
        }
    }()
    a[i] = i // Potential out-of-bounds error if i is too large
    fmt.Println(a)
}

func main() {
    a := make([]int, 4)
    for i := 0; i < 5; i++ {
        go addele(a, i)
    }
    // ... (add synchronization to wait for goroutines to finish) ...
}

Beispiel 2: Verwendung von Kanälen zur Synchronisierung

package main

import (
    "fmt"
    "sync"
)

func cal(a, b int, wg *sync.WaitGroup) {
    defer wg.Done()
    c := a + b
    fmt.Printf("%d + %d = %d\n", a, b, c)
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go cal(i, i+1, &wg)
    }
    wg.Wait()
}

Kommunikation zwischen Goroutinen

Kanäle erleichtern die Kommunikation und den Datenaustausch zwischen Goroutinen. Es können auch globale Variablen verwendet werden, im Allgemeinen werden jedoch Kanäle zur besseren Kontrolle der Parallelität bevorzugt.

Beispiel: Produzenten-Konsumenten-Muster

package main

import (
    "fmt"
)

func cal(a, b int, ch chan bool) {
    c := a + b
    fmt.Printf("%d + %d = %d\n", a, b, c)
    ch <- true // Signal completion
}

func main() {
    ch := make(chan bool, 10) // Buffered channel to avoid blocking
    for i := 0; i < 10; i++ {
        go cal(i, i+1, ch)
    }
    for i := 0; i < 10; i++ {
        <-ch // Wait for each goroutine to finish
    }
}

Leapcell: Eine serverlose Plattform für Go

Leapcell ist eine empfohlene Plattform für die Bereitstellung von Go-Diensten.

Hauptmerkmale:

1. Mehrsprachige Unterstützung: JavaScript, Python, Go, Rust.
2. Kostenlose unbegrenzte Projekte:Pay-as-you-go-Preise.
3. Kostengünstig:Keine Leerlaufgebühren.
4. Entwicklerfreundlich: Intuitive Benutzeroberfläche, automatisiertes CI/CD, Echtzeitmetriken.
5. Skalierbar und leistungsstark: Automatische Skalierung, kein Betriebsaufwand.

Erfahren Sie mehr in der Dokumentation!

Leapcell Twitter: https://www.php.cn/link/7884effb9452a6d7a7a79499ef854afd

Das obige ist der detaillierte Inhalt vonGo's Concurrency Decoded: Goroutine Scheduling. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!