Let’s talk about Barrier in golang

When writing concurrent code, it is often necessary to ensure synchronization between multiple goroutines and mutual tokens or locks to prevent data competition and race conditions. The Go language provides some mechanisms to achieve these synchronizations through the chan and sync packages, but sometimes they are not flexible enough and require more advanced synchronization methods. In this case, barriers need to be used.

The barrier is a synchronization primitive that is used to wait for a group of goroutines to complete an operation at the same time before continuing to the next operation. This is a very common synchronization mechanism. Golang also provides a mechanism to implement barriers, namely "Barrier".

The principle of the barrier is to divide a group of goroutines into two stages. In the first stage, each goroutine stops after completing its own tasks and waits for other goroutines to complete. In the second stage, when all goroutines have completed When stopped and setting signals to each other, all goroutines resume execution simultaneously.

Golang provides the "WaitGroup" type in the sync package. Use the Add method to add the number of waiting goroutines. The Done method is used to reduce a counter to the WaitGroup after each goroutine completes the task. Finally, the Wait method blocks. Until the counter drops to zero, that is, all goroutines have completed their tasks, the next step will not be continued.

However, WaitGroup has a disadvantage. It can only wait for a fixed number of goroutines to complete. When new goroutines join, we cannot use it. At this time, we can use Barrier to solve this problem.

Barrier can be used with any number of goroutines and can perform any specified operations at the end of each stage. It contains a counter indicating how many goroutines are waiting for the set of operations to complete, and a function to execute at the end of each stage.

"A group of waiting threads" in Golang can be implemented using the "WaitGroup (waiting group)" of the sync package:

var wg sync.WaitGroup

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

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

Now, we use "Barrier" to create a Example of changing goroutine:

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")
}

This example creates 20 goroutines, which are divided into two phases. The first phase waits for each goroutine to complete its task, and the second phase waits for all goroutines to complete their tasks. Do not perform the operation until complete.

When two groups of goroutines are created, one of the goroutines calls "Wait" and blocks until all goroutines complete their tasks. When other threads have completed their tasks, the blocking is released and signals are sent to all goroutines using "Broadcast" to continue the next step.

In short, Golang's Barrier allows you to synchronize concurrent operations at a more advanced level and make your code more robust and reliable.

The above is the detailed content of Let’s talk about Barrier in golang. For more information, please follow other related articles on the PHP Chinese website!