Efficient concurrent programming practice: Go WaitGroup usage tips in Golang

Efficient concurrent programming practice: Go WaitGroup usage tips in Golang

Introduction: Concurrent programming is a vital part of today's software development field. In large-scale systems, efficient concurrent processing can significantly improve system performance and throughput. As a language that emphasizes concurrency, Golang provides a wealth of concurrent programming tools and features. One of them is WaitGroup. This article will introduce the usage skills of WaitGroup in Golang and provide specific code examples.

1. What is WaitGroup?
WaitGroup is a concurrent synchronization primitive in Golang, which is used to wait for the completion of a group of goroutines. Usually the Add method of WaitGroup is used in the main goroutine to set the number of goroutines to wait for, and then the Wait method is used to wait for them all to complete.

2. Basic usage of WaitGroup
The following is a basic usage example of WaitGroup:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

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

    // 启动goroutine
    go printMessage("Hello", &wg)
    go printMessage("World", &wg)

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

    fmt.Println("All goroutines finished.")
}

func printMessage(message string, wg *sync.WaitGroup) {
    // 在函数结束时通知WaitGroup当前goroutine已经完成
    defer wg.Done()

    fmt.Println(message)
    time.Sleep(time.Second)
}

In the above example, we created a WaitGroup object wg and used the Add method to indicate the need The number of waiting goroutines is 2. Then, we started two goroutines to execute the printMessage function, and each goroutine outputs a message after one second. In the printMessage function, we use defer wg.Done() to notify WaitGroup that the current goroutine has completed. Finally, we use wg.Wait() to wait for all goroutines to complete.

3. Common skills of WaitGroup
In addition to the basic usage, we can also use WaitGroup in combination with other features to achieve other efficient concurrent programming techniques. Here are some common techniques:

1. Use anonymous functions for concurrent processing

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    names := []string{"Alice", "Bob", "Charlie"}

    // 设置需要等待的goroutine数
    wg.Add(len(names))

    for _, name := range names {
        go func(n string) {
            // 在函数结束时通知WaitGroup当前goroutine已经完成
            defer wg.Done()

            fmt.Println("Hello,", n)
        }(name)
    }

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

    fmt.Println("All goroutines finished.")
}

In the above example, we use WaitGroup combined with anonymous functions to concurrently process a list of names. By using anonymous functions inside the loop, we can tie the goroutine to a specific operation, thus avoiding possible race conditions.

2. Wait for a specific number of goroutines to complete

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    // 设置需要等待的goroutine数
    wg.Add(3)

    go printMessage("Hello", &wg)
    go printMessage("World", &wg)

    // 在前两个goroutine完成之后，继续启动一个goroutine
    go func() {
        printMessage("Golang", &wg)
        wg.Done()
    }()

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

    fmt.Println("All goroutines finished.")
}

func printMessage(message string, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Println(message)
}

In the above example, we set the number of goroutines to wait to 3, and after the first two goroutines complete , the third goroutine is started. This ensures that the first two goroutines are completed before starting the third goroutine.

4. Summary
This article introduces the basic usage of WaitGroup in Golang and provides some common techniques. By using WaitGroup properly, we can easily implement efficient concurrent programming. In actual development, we should flexibly use WaitGroup according to specific problems and scenarios, and combine it with other concurrency primitives to improve the system's performance and concurrency processing capabilities.

Through the study of this article, we hope that readers can master the skills of using WaitGroup, and be able to rationally use concurrent programming in actual projects, thereby improving the performance and reliability of the system.

The above is the detailed content of Efficient concurrent programming practice: Go WaitGroup usage tips in Golang. For more information, please follow other related articles on the PHP Chinese website!