Efficient combination of Golang WaitGroup and coroutine pool

The efficient combination of Golang WaitGroup and coroutine pool requires specific code examples

Introduction:
Go language is a language that emphasizes concurrent programming. Efficient concurrent execution is achieved through goroutine. In some scenarios where multiple tasks need to be executed simultaneously, the combination of WaitGroup and coroutine pool can effectively improve program execution efficiency and resource utilization. This article will introduce how to use WaitGroup and coroutine pool in Golang to achieve efficient concurrent programming, and provide specific code examples.

1. Introduction to WaitGroup
WaitGroup is a tool in Go language used to wait for the completion of the execution of a group of coroutines. Its source code is defined as follows:

type WaitGroup struct {
    noCopy noCopy

    // 64位的值：高32位存储计数器，低32位存储等待计数器
    // 这个变量可以被原子操作加载和存储。
    // 在64位同步原语中，它必须在64位边界对齐。
    // 是一个强制的要求。
    state1 [3]uint32
}

WaitGroup is usually created in the main goroutine, and then each sub-goroutine in the main goroutine calls the Add method to increase the counter, and after the execution is completed, the Done method is used to decrement the counter. The main goroutine can wait for the counter to return to zero through the Wait method. The specific sample code is as follows:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(3)

    go func() {
        defer wg.Done()
        fmt.Println("Task 1 executing")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Task 2 executing")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Task 3 executing")
    }()

    wg.Wait()
    fmt.Println("All tasks completed")
}

In the above example, we create a WaitGroup object and then increase the counter by calling the Add method. Next, we created three sub-goroutines, and after each goroutine is executed, the counter is decremented through the Done method. Finally, the main goroutine waits for the counter to return to zero by calling the Wait method. When all tasks are completed, the program will output "All tasks completed".

2. Introduction to the coroutine pool
In concurrent programming, the coroutine pool (goroutine pool) is a commonly used mode. By creating a fixed number of goroutines and evenly distributing tasks to them, you can avoid the overhead of constantly creating and destroying goroutines. In Go language, you can use channels to implement coroutine pools. The specific sample code is as follows:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        fib := fibonacci(j)
        fmt.Println("Worker", id, "finished job", j)
        results <- fib
    }
}

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }

    return fibonacci(n-1) + fibonacci(n-2)
}

const numJobs = 5
const numWorkers = 3

func main() {
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    var wg sync.WaitGroup
    wg.Add(numWorkers)

    for w := 1; w <= numWorkers; w++ {
        go func(id int) {
            defer wg.Done()
            worker(id, jobs, results)
        }(w)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    wg.Wait()

    for r := 1; r <= numJobs; r++ {
        fmt.Println(<-results)
    }
}

In the above example, we defined the worker function, which reads the pending tasks from the jobs channel, then executes the tasks and sends the results to the results channel. We created a jobs channel and a results channel to implement the function of the coroutine pool by distributing tasks and obtaining results.

In the main function, we use WaitGroup to wait for all workers (goroutines) to complete task execution. Then, we send the tasks to be executed to the jobs channel and close the channel after execution. Finally, we get the calculation results from the results channel and output them.

3. An efficient combination case of WaitGroup and coroutine pool
Next, we will combine the above two concepts to introduce how to effectively use WaitGroup and coroutine pool to implement concurrent programming. The specific sample code is as follows:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        fib := fibonacci(j)
        fmt.Println("Worker", id, "finished job", j)
        results <- fib
    }
}

func fibonacci(n int) int {
    if n <= 1 {
        return n
    }

    return fibonacci(n-1) + fibonacci(n-2)
}

const numJobs = 5
const numWorkers = 3

func main() {
    var wg sync.WaitGroup
    wg.Add(numWorkers)

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    for w := 1; w <= numWorkers; w++ {
        go func(id int) {
            defer wg.Done()
            worker(id, jobs, results)
        }(w)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    go func() {
        wg.Wait()
        close(results)
    }()

    for r := range results {
        fmt.Println(r)
    }
}

In the above example, we created a WaitGroup object and incremented the counter by calling the Add method. Then, we created a jobs channel and a results channel to distribute tasks and obtain results. We create a fixed number of workers (goroutines) and use the Wait method to wait for them to complete their tasks.

In the main function, we send the tasks to be executed to the jobs channel and close the channel after completion. We then start a coroutine to wait for all workers to complete their tasks and close the results channel when completed. Finally, we output the calculation results by getting them from the results channel.

Conclusion:
By combining WaitGroup and coroutine pool, we can efficiently implement concurrent programming. By using a WaitGroup to wait for the execution of a group of goroutines to complete, you can ensure that the main goroutine continues to execute after all tasks are completed. By using the coroutine pool, we can avoid the overhead of frequently creating and destroying goroutines and improve the execution efficiency and resource utilization of the program.

The Fibonacci sequence calculation in the code example is just a demonstration example, and can be replaced with other tasks according to specific needs in actual applications. Using WaitGroup and coroutine pool, we can better control the number of concurrently executed tasks and effectively utilize computing resources.

Although the Go language provides a wealth of concurrent programming tools and features, you still need to be cautious when using them. Proper use of WaitGroup and coroutine pool can help us better manage and schedule goroutines and achieve efficient concurrent programming.

The above is the detailed content of Efficient combination of Golang WaitGroup and coroutine pool. For more information, please follow other related articles on the PHP Chinese website!