Task monitoring and error handling: best practices for using Go WaitGroup in Golang

Task monitoring and error handling: Best practices for using Go WaitGroup in Golang

Introduction:
In the Go language, task monitoring can be achieved using WaitGroup and error handling. WaitGroup is used to wait for the completion of a group of tasks and can effectively control the number of concurrently executed tasks. This article will introduce the best practices for using WaitGroup in Golang and provide specific code examples.

1. Introduction
   When developing concurrent programs, we often encounter situations where we need to wait for a group of tasks to complete. In Golang, this goal can be easily achieved using WaitGroup. WaitGroup is a concurrency control mechanism provided by Golang for waiting for the completion of a group of tasks.
   The following are the three main steps to use WaitGroup:
2. Declare WaitGroup variables: introduce WaitGroup through the sync package, and use sync.WaitGroup to declare a WaitGroup variable.
3. Increase the number of tasks: Before starting each task, use the Add method of WaitGroup to increase the number of tasks.
4. Mark task completion: When each task is completed, mark the completion of the task by calling the Done method of WaitGroup.
5. Wait for task completion: After all tasks are started, wait for the completion of all tasks by calling the Wait method of WaitGroup.
6. Sample code
   The following is a sample code using WaitGroup to execute a set of tasks concurrently and output the results after all tasks are completed:

package main

import (
    "fmt"
    "sync"
)

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

    // 模拟任务的处理
    fmt.Printf("Worker %d starting
", id)
    // 执行任务...
    fmt.Printf("Worker %d done
", id)
}

func main() {
    // 声明WaitGroup变量
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1) // 增加任务数量

        // 启动任务
        go worker(i, &wg)
    }

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

    fmt.Println("All workers have finished")
}

Above In the code, the worker function simulates the processing of a task. In the main function, we first declare a WaitGroup variable wg. Then, use wg.Add(1) to increase the number of tasks before starting each task. Then, when starting each task, execute the worker function concurrently through the go keyword and pass the WaitGroup to each task. Finally, wait for the completion of all tasks by calling wg.Wait(). When all tasks are completed, the program will output "All workers have finished".

3. Error handling
   In actual development, errors may occur in tasks. In order to handle these errors, we can combine WaitGroup with the error type. The following is a sample code for processing tasks that contain errors:

package main

import (
    "errors"
    "fmt"
    "sync"
)

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

    // 模拟任务的处理
    fmt.Printf("Worker %d starting
", id)

    // 执行任务...
    // 如果任务出现错误，设置一个错误
    err := errors.New("task failed")

    fmt.Printf("Worker %d done
", id)
    return err
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)

        go func(id int) {
            defer wg.Done()

            // 执行任务，并处理错误
            if err := worker(id, &wg); err != nil {
                // 错误处理
                fmt.Printf("Worker %d encountered an error: %v
", id, err)
            }
        }(i)
    }

    wg.Wait()

    fmt.Println("All workers have finished")
}

In the above code, the worker function simulates a task processing process that may cause errors. In the main function, we use anonymous functions to start each task and handle errors by passing the WaitGroup variable. In the anonymous function, we call the worker function to perform the task, and obtain the return value of the task through err := worker(id, &wg), which is the error type. If an error occurs during task execution, we can handle the error by determining whether err is nil.

Summary:
In this article, we introduced the best practices for using WaitGroup in Golang and provided specific code examples. By using WaitGroup, we can easily implement task monitoring and error handling. When you need to wait for a group of tasks to complete, using WaitGroup can effectively control the number of concurrently executed tasks and handle possible errors, thereby improving the stability and reliability of the program. I hope this article can help you use WaitGroup to handle task monitoring and error handling in Golang.

The above is the detailed content of Task monitoring and error handling: best practices for using Go WaitGroup in Golang. For more information, please follow other related articles on the PHP Chinese website!