Detailed explanation of usage and examples of Go WaitGroup

Go language is a programming language with concurrent programming as its core and is very efficient in handling concurrent tasks. In the standard library of the Go language, there is a very useful concurrency tool-WaitGroup. This article will introduce the use of WaitGroup in detail and demonstrate its specific application through examples.

First of all, we need to understand the role of WaitGroup. WaitGroup is used to wait for a group of concurrent tasks to complete before continuing to execute subsequent code. Normally, we can use WaitGroup when the main coroutine needs to wait for other coroutines to complete a certain task before continuing execution.

Under the sync package of Go language, there is a WaitGroup structure, which has three main methods, namely Add(), Done() and Wait(). Below we introduce their functions one by one.

The first is the Add() method, which is used to increase the number of waiting tasks. We can tell the WaitGroup how many tasks we need to wait for completion by calling the Add() method. The specific calling method is wg.Add(n), where n represents the number of tasks to wait. For example, if we have 10 tasks waiting to be completed, we can call wg.Add(10).

Then there is the Done() method, which is used to mark that the current task has been completed. When each task is completed, the Done() method needs to be called to tell the WaitGroup that the current task has been completed. The specific calling method is wg.Done(). Normally, we will call the Done() method in the defer statement after the task is completed to ensure that the Done() method will be called after the task is completed.

Finally is the Wait() method, which is used to block the main coroutine until all tasks have been completed. When the main coroutine needs to wait for a set of tasks to be completed before continuing to execute subsequent code, the Wait() method can be called. The specific calling method is wg.Wait(). The Wait() method will block until all tasks have been completed.

Below we demonstrate the specific application of WaitGroup through an example. Suppose we have a list of tasks that we need to process concurrently. After each task is completed, we write the results to a results list. Finally, we need to wait until all tasks are completed before printing the results list. The code is as follows:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    taskList := []string{"task1", "task2", "task3", "task4"}

    // 创建结果列表
    resultList := make([]string, len(taskList))

    // 遍历任务列表，开启多个协程处理任务
    for i, task := range taskList {
        wg.Add(1) // 增加等待的任务数

        go func(index int, task string) {
            defer wg.Done() // 标志任务已经完成

            // 模拟任务处理过程
            result := fmt.Sprintf("task %s processed", task)

            // 将结果写入结果列表
            resultList[index] = result
        }(i, task)
    }

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

    // 打印结果列表
    for _, result := range resultList {
        fmt.Println(result)
    }
}

In the above code, first we create a WaitGroup object wg. Then, we traverse the task list and call wg.Add(1) once for each task, indicating that there is a task to wait for. In the handler function of each task, we call wg.Done() once after the task is completed. Finally, we called wg.Wait() in the main coroutine to wait for all tasks to complete.

Through this design, we can process tasks concurrently and ensure that after all tasks are completed, we can continue the subsequent execution of the main coroutine. Finally, we printed out the result list to verify the concurrent processing of tasks and the correctness of the results.

In summary, WaitGroup is a very practical concurrency tool in the Go language. By using WaitGroup properly, we can better manage concurrent tasks and ensure the order and correctness of tasks. I hope this article can help readers better understand and apply WaitGroup.

The above is the detailed content of Detailed explanation of usage and examples of Go WaitGroup. For more information, please follow other related articles on the PHP Chinese website!