Simple and practical: Sharing application examples of Go WaitGroup

Simple and practical: Go WaitGroup application example sharing

Introduction:
Go language is a concurrent programming language with many built-in tools and features for concurrent processing. . One of them is sync.WaitGroup, which provides an elegant and simple way to wait for the completion of a group of concurrent tasks. This article will share a specific application example, showing how to use WaitGroup to speed up the execution of concurrent tasks.

What is WaitGroup?
sync.WaitGroup is a structure in the Go language standard library, used to wait for the completion of a group of concurrent tasks. It maintains a counter internally and can increment and decrement the counter value. When the value of the counter becomes 0, it means that all tasks have been completed and the blocking operation inside WaitGroup will be released.

Application Example:
Suppose we have a requirement to crawl data from multiple web pages, and do so at the same time to speed up data acquisition. We can use WaitGroup to execute these crawler tasks concurrently. Here is a sample code:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
)

func crawl(url string, wg *sync.WaitGroup) {
    defer wg.Done()

    resp, err := http.Get(url)
    if err != nil {
        fmt.Printf("发生错误：%s
", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("发生错误：%s
", err)
        return
    }

    fmt.Printf("爬取完成：%s
", url)
    // TODO: 处理网页内容
}

func main() {
    urls := []string{
        "https://www.example.com",
        "https://www.google.com",
        "https://www.microsoft.com",
    }

    var wg sync.WaitGroup
    for _, url := range urls {
        wg.Add(1)
        go crawl(url, &wg)
    }

    wg.Wait()
    fmt.Println("所有任务已完成")
}

In the above code, we define a crawl function to perform a single crawler task. The crawl function accepts a URL and a WaitGroup pointer as parameters. Inside the function, we use http.Get to send an HTTP request and then read the contents of the response. When the task is completed, we call wg.Done() to decrement the WaitGroup counter.

In the main function, we define a URL list and use WaitGroup to process the crawler task corresponding to each URL. When traversing the URL list, we use wg.Add(1) to increment the counter of WaitGroup, and use the go keyword to create a new goroutine for concurrency perform tasks.

Finally, we call wg.Wait() to wait for the completion of all tasks. Once all tasks are completed, the program will continue executing the following code.

Summary:
Through this application example, we have seen the role of sync.WaitGroup in concurrent programming. It simplifies the process of coordinating and controlling concurrent tasks, making concurrent programming simple and easy to understand. At the same time, we should also note that in order to ensure the safety of concurrent tasks, we need to provide appropriate mutual exclusion protection for shared resources.

Hope the above examples can help readers better understand and use sync.WaitGroup to speed up the execution of concurrent tasks.

The above is the detailed content of Simple and practical: Sharing application examples of Go WaitGroup. For more information, please follow other related articles on the PHP Chinese website!