Go WaitGroup and best practices for concurrent programming in Golang

Go WaitGroup and best practices for concurrent programming in Golang

Summary:
In concurrent programming, Go WaitGroup is an important tool. This article will introduce what WaitGroup is and how to use it to manage concurrent tasks. It will also provide some practical code examples to help readers better understand and use WaitGroup.

Introduction:
With the development of computer hardware, multi-core processors have become the standard configuration of modern computers. In order to take full advantage of the performance advantages of multi-core processors, we need to use concurrent programming to achieve simultaneous execution of tasks. Go language is a powerful concurrent programming language that provides a series of concurrent programming tools and mechanisms.

In the Go language, WaitGroup is an important tool for coordinating concurrent tasks. It allows us to wait for a set of concurrent tasks to complete before continuing to the next step, thereby effectively managing and controlling concurrent tasks. This article will introduce the principles and usage of WaitGroup in detail, and provide some common usage scenarios and code examples in actual projects.

1. The principle and basic usage of WaitGroup
1.1 The basic principle of WaitGroup
In concurrent programming, WaitGroup functions like a counter. We can add the number of tasks that need to be waited for to the WaitGroup through the Add method, and then indicate that a task has been completed through the Done method. By calling the Wait method, we can block the main thread until all tasks are completed. When the counter in the WaitGroup reaches 0, the main thread continues execution.

1.2 Basic usage of WaitGroup
Before using WaitGroup, we first need to import the sync package, because WaitGroup is part of the package. Next, we need to create a WaitGroup object and then add the number of tasks to wait for by calling the Add method. Afterwards, before each task starts, we need to call the Done method inside the task to indicate task completion. Finally, we can call the Wait method to block the main thread until all tasks are completed.

The following is a basic usage example:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    wg.Add(2)

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

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

    wg.Wait()

    fmt.Println("All tasks completed")
}

In the above code, we create a WaitGroup object and use the Add method to set the number of tasks to 2. Then, we use two anonymous functions to perform task 1 and task 2 respectively. At the end of each task, we use the defer keyword to call the Done method. Finally, we call the Wait method to block the main thread until all tasks are completed. When all tasks are completed, the program will print out "All tasks completed".

2. Advanced usage of Go WaitGroup
2.1 Error handling in concurrent tasks
In actual application scenarios, we often encounter errors in concurrent tasks. To be able to handle these errors efficiently and avoid program crashes, we need to pass the errors to the main thread. In Go language, we can use channels to pass errors.

The following is a sample code for handling errors in concurrent tasks:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    errChan := make(chan error)

    wg.Add(2)

    go func() {
        defer wg.Done()
        err := task1()
        if err != nil {
            errChan <- err
        }
    }()

    go func() {
        defer wg.Done()
        err := task2()
        if err != nil {
            errChan <- err
        }
    }()

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

    for err := range errChan {
        fmt.Println("Error:", err)
    }

    fmt.Println("All tasks completed")
}

func task1() error {
    // 执行任务1
    return nil
}

func task2() error {
    // 执行任务2
    return nil
}

In the above code, we create a channel (errChan) to pass errors. At the end of each task, if an error occurs, we send the error to errChan. Next, we use a for loop to receive the error in errChan and handle it. When all tasks are completed, the program will print out "All tasks completed". Please note that task1 and task2 are simulated example functions and we can replace them according to actual needs.

2.2 Control the number of concurrent tasks
Sometimes, we may need to limit the number of concurrent tasks to avoid excessive consumption of resources. In the Go language, we can use WaitGroup and Semaphore to control the number of concurrent tasks.

The following is a sample code to control the number of concurrent tasks:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    sem := make(chan int, 3)  // 限制并发任务数量为3

    for i := 0; i < 5; i++ {
        wg.Add(1)
        sem <- 1 // 请求一个信号量，表示可以开始一个新的任务
        go func(taskIndex int) {
            defer wg.Done()
            fmt.Println("Task", taskIndex, "executed")
            <-sem // 释放一个信号量，表示任务执行完成
        }(i)
    }

    wg.Wait()
    close(sem)

    fmt.Println("All tasks completed")
}

In the above code, we create a buffered channel (sem) to store the semaphore. By setting the capacity of the channel to 3, we can limit the number of concurrent tasks to 3. At the beginning of each task, we first request a semaphore to indicate that a new task can be started. Then, at the end of each task, we release a semaphore via <-sem.

3. Summary
Through the introduction of this article, we have learned about the basic principles and usage of Go WaitGroup, as well as some advanced usage. By using WaitGroup properly, we can better manage and control concurrent tasks, thereby improving program performance and reliability.

It should be noted that in actual development, we also need to pay attention to handling errors in concurrent tasks and reasonably control the number of concurrent tasks. These are advanced techniques for using WaitGroup that can help us build more robust and efficient concurrent applications.

I hope this article can help readers better understand and use Go WaitGroup, and take advantage of it in actual projects. I wish you all the best to go further and further on the road to concurrent programming!

The above is the detailed content of Go WaitGroup and best practices for concurrent programming in Golang. For more information, please follow other related articles on the PHP Chinese website!