Rapid Deployment: Application Guide of Go WaitGroup in Golang Projects

Quick Deployment: Go WaitGroup Application Guide in Golang Projects

Introduction:
In concurrent programming, it is common to wait for all goroutines to complete their tasks Task. Go WaitGroup is a powerful tool in Golang for this purpose. This article will introduce the basic concepts of Go WaitGroup and provide some specific code examples to help readers quickly deploy and apply WaitGroup in Golang projects.

1. What is WaitGroup?
WaitGroup is a concurrency primitive in Golang, which is used to wait for a group of goroutines to complete tasks. It mainly provides three methods:

1. Add: Add a waiting goroutine to WaitGroup.
2. Done: Marks a waiting goroutine task as completed.
3. Wait: Wait for all pending goroutines to complete their tasks.

Through the combined use of these three methods, we can easily wait for all goroutine tasks to be completed and then perform subsequent operations.

2. Code examples:
In order to better understand the usage and application scenarios of WaitGroup, two specific code examples will be given below.

Example 1:
In this example, we use WaitGroup to wait for a group of goroutines to complete execution.

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()

    fmt.Printf("Worker %d starting
", id)

    // 模拟一些耗时的操作
    for i := 0; i < 5; i++ {
        fmt.Printf("Worker %d working...
", id)
    }

    fmt.Printf("Worker %d finished
", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()

    fmt.Println("All workers finished")
}

In the above code, we define a worker function to simulate some time-consuming operations. In the main function, we use a loop to create 5 goroutines, and add the waiting goroutine to the WaitGroup by calling wg.Add(1). Then, after each goroutine completes its task, it marks the task as completed by calling wg.Done(). Finally, call wg.Wait() in the main function to wait for all goroutines to complete, and then output "All workers finished".

Example 2:
In this example, we use WaitGroup and channel to implement the main goroutine to wait for all child goroutines to complete the task and aggregate the results.

package main

import (
    "fmt"
    "sync"
)

func worker(id int, wg *sync.WaitGroup, result chan<- int) {
    defer wg.Done()

    fmt.Printf("Worker %d starting
", id)

    // 模拟一些耗时的操作
    sum := 0
    for i := 0; i < 5; i++ {
        sum += i
    }

    fmt.Printf("Worker %d finished, result: %d
", id, sum)
    result <- sum
}

func main() {
    var wg sync.WaitGroup
    result := make(chan int, 5)

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg, result)
    }

    wg.Wait()
    close(result)

    total := 0
    for r := range result {
        total += r
    }

    fmt.Printf("All workers finished, total result: %d
", total)
}

In the above code, we pass each goroutine calculation result back to the main goroutine through the channel in the worker function, and finally summarize all results in the main goroutine. By using the combination of WaitGroup and channel, we can more flexibly implement goroutine task waiting and result summary.

3. Summary:
Go WaitGroup is an important tool for implementing concurrent task waiting in Golang. This article gives two specific code examples to help readers quickly understand and deploy the application of WaitGroup in Golang projects. I hope readers can make full use of this powerful tool to improve the concurrency performance and reliability of the project.

The above is the detailed content of Rapid Deployment: Application Guide of Go WaitGroup in Golang Projects. For more information, please follow other related articles on the PHP Chinese website!