Lassen Sie uns über Barrier in Golang sprechen

Beim Schreiben von gleichzeitigem Code ist es häufig erforderlich, die Synchronisierung zwischen mehreren Goroutinen und gegenseitigen Token oder Sperren sicherzustellen, um Datenkonkurrenz und Rennbedingungen zu verhindern. Die Go-Sprache bietet einige Mechanismen, um diese Synchronisierungen über die Pakete chan und sync zu erreichen, aber manchmal sind sie nicht flexibel genug und erfordern fortgeschrittenere Synchronisierungsmethoden. In diesem Fall sind Barrieren erforderlich.

Eine Barriere ist ein Synchronisationsprimitiv, das verwendet wird, um darauf zu warten, dass eine Gruppe von Goroutinen gleichzeitig einen Vorgang abschließt, bevor mit dem nächsten Vorgang fortgefahren wird. Dies ist ein sehr häufiger Synchronisationsmechanismus. Golang bietet auch einen Mechanismus zur Implementierung von Barrieren, nämlich „Barrier“.

Das Prinzip der Barriere besteht darin, eine Gruppe von Goroutinen in zwei Phasen zu unterteilen. Die erste Phase wird gestoppt, nachdem jede Goroutine ihre eigene Aufgabe abgeschlossen hat und auf den Abschluss anderer Goroutinen wartet, und die zweite Phase ist, wenn alle Goroutinen gestoppt wurden und richten sich gegenseitig ein. Wenn ein Signal gegeben wird, nehmen alle Goroutinen gleichzeitig die Ausführung wieder auf.

Golang stellt den Typ „WaitGroup“ im Synchronisierungspaket bereit. Verwenden Sie die Add-Methode, um die Anzahl der wartenden Goroutinen hinzuzufügen. Die Done-Methode wird verwendet, um einen Zähler zur WaitGroup zu reduzieren. Schließlich wird die Wait-Methode verwendet blockiert, bis der Zähler auf Null fällt, d. h. alle Goroutinen haben ihre Aufgaben abgeschlossen, bevor sie mit dem nächsten Schritt fortfahren.

WaitGroup hat jedoch einen Nachteil: Es kann nur warten, bis eine feste Anzahl von Goroutinen abgeschlossen ist, und wir können es nicht verwenden. Zu diesem Zeitpunkt können wir Barrier verwenden, um dieses Problem zu lösen.

Barrier kann mit einer beliebigen Anzahl von Goroutinen verwendet werden und kann am Ende jeder Phase alle angegebenen Vorgänge ausführen. Es enthält einen Zähler, der angibt, wie viele Goroutinen auf den Abschluss der Reihe von Operationen warten, und eine Funktion, die am Ende jeder Phase ausgeführt wird.

„Eine Gruppe wartender Threads“ in Golang kann mithilfe der „WaitGroup“ des Synchronisierungspakets implementiert werden:

var wg sync.WaitGroup

func worker() {
    defer wg.Done()
    // 执行自己的任务
}

func main() {
    for i := 0; i < n; i++ {
        wg.Add(1)
        go worker()
    }
    // 等待所有线程完成
    wg.Wait()
}

Jetzt verwenden wir „Barrier“, um ein Beispiel für eine Goroutine zu erstellen, die auf Änderungen angewendet werden kann:

package main

import "fmt"
import "sync"

func main() {
    b := sync.NewCond(&sync.Mutex{})
    done := make(chan bool)

    worker := func(id int) {
        defer func() {
            fmt.Printf("Worker %d done\n", id)
            done <- true
        }()
        fmt.Printf("Worker %d processing\n", id)
        b.L.Lock()
        b.Wait() // 等待阻塞直到b.Broadcast()被执行
        b.L.Unlock()
        fmt.Printf("Worker %d resumed\n", id)
    }

    go func() {
        for i := 0; i < 10; i++ {
            wg.Add(1)
            go worker(i)
        }
    }()

    go func() {
        for i := 0; i < 10; i++ {
            wg.Add(1)
            go worker(i)
        }
    }()

    go func() {
        wg.Wait()
        b.Broadcast()
    }()

    for i := 0; i < 20; i++ {
        <-done
    }
    fmt.Printf("All workers done\n")
}

In diesem Beispiel werden 20 Goroutinen erstellt, die in zwei Phasen unterteilt sind. Die erste Phase wartet darauf, dass jede Goroutine ihre eigene Aufgabe erledigt, und die zweite Phase wartet darauf, dass alle Goroutinen abgeschlossen sind, bevor der Vorgang ausgeführt wird.

Wenn zwei Gruppen von Goroutinen erstellt werden, ruft eine der Goroutinen „Warten“ auf und blockiert, bis alle Goroutinen ihre Aufgaben abgeschlossen haben. Wenn andere Threads ihre Aufgaben erledigt haben, wird die Blockierung aufgehoben und mittels „Broadcast“ werden Signale an alle Goroutinen gesendet, um mit dem nächsten Schritt fortzufahren.

Kurz gesagt: Mit Golangs Barrier können Sie gleichzeitige Vorgänge auf einem fortgeschritteneren Niveau synchronisieren und Ihren Code robuster und zuverlässiger machen.

Das obige ist der detaillierte Inhalt vonLassen Sie uns über Barrier in Golang sprechen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!