Master the sync.WaitGroup function in the Go language documentation to implement concurrency control

Mastering the sync.WaitGroup function in the Go language document to implement concurrency control requires specific code examples

It is very important to implement concurrency control in the Go language, and sync The WaitGroup function in the package provides a simple and efficient way to implement concurrency control. This article will introduce in detail how to use the sync.WaitGroup function and provide specific code examples.

In concurrent programming, it is often necessary to wait for all goroutines to complete before continuing to execute subsequent code. This can be easily achieved using the sync.WaitGroup function. The WaitGroup function in the sync package contains three main methods: Add, Done and Wait.

First, use the Add method to set the number of goroutines to wait for. Then, use the Done method at the end of each goroutine to indicate that the goroutine has completed. Finally, use the Wait method to wait for all goroutines to complete.

The following is a simple example showing how to use the sync.WaitGroup function to achieve concurrency control:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    // 设置要等待的goroutine的数量
    wg.Add(2)

    go func() {
        defer wg.Done()
        // 模拟第一个任务
        fmt.Println("Executing Task 1")
    }()

    go func() {
        defer wg.Done()
        // 模拟第二个任务
        fmt.Println("Executing Task 2")
    }()

    // 等待所有的goroutine完成
    wg.Wait()

    // 所有的goroutine已经完成，执行后续的代码
    fmt.Println("All tasks completed")
}

In the above example, we first create a WaitGroup using the variable wg of the sync.WaitGroup type Example. Then, set the number of goroutines to wait by calling the Add method, here is 2 goroutines. Then, we create two goroutines, each goroutine will perform some tasks and at the end indicate that it has completed by calling the Done method. Finally, by calling the Wait method, the main goroutine will wait for all goroutines to complete.

The task in the above example is very simple, just print some text. However, the logic of the task can be modified according to actual needs.

In summary, the sync.WaitGroup function provides a simple and effective method to achieve concurrency control. By setting the WaitGroup counter appropriately and calling the Done method in each goroutine, you can achieve the effect of waiting for all goroutines to complete. This is very useful for controlling concurrent tasks and ensuring that all goroutines have completed their tasks before continuing to execute subsequent code.

The above is the detailed content of Master the sync.WaitGroup function in the Go language documentation to implement concurrency control. For more information, please follow other related articles on the PHP Chinese website!