Home >Backend Development >Golang >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!