How Golang functions efficiently handle parallel tasks

Efficient parallel task handling in Go functions: Use the go keyword to launch concurrent routines. Use sync.WaitGroup to count the number of outstanding routines. When the routine completes, wg.Done() is called to decrement the counter. The main program blocks using wg.Wait() until all routines complete. Practical case: Send web requests concurrently and collect responses.

Efficient parallel task processing in Go functions

The Go language provides powerful parallel processing capabilities, allowing developers to easily Create and execute concurrent tasks independently. This article will discuss how to use Go functions to efficiently handle parallel tasks and provide a practical case to demonstrate its usage.

Concurrency in Go functions

The Go function provides two keywords to support concurrent execution: go and sync.WaitGroup . The go keyword is used to start concurrent Go routines, while the sync.WaitGroup is used to wait for all routines to complete.

Wait Group

sync.WaitGroup is a counter used to track the number of outstanding routines. When the routine completes, it calls wg.Done() to decrement the counter. The main program can use the wg.Wait() method to block until all routines are completed.

Practical case: Concurrent Web requests

Consider a scenario where we need to send multiple Web requests concurrently and collect responses. The following is code that demonstrates how to use Go functions for efficient concurrent task processing:

package main

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

func main() {
    // 要发送的 Web 请求 URL
    urls := []string{"https://example.com", "https://example2.com", "https://example3.com"}

    // 创建等待组
    var wg sync.WaitGroup

    for _, url := range urls {
        // 启动一个并发例程来发送 Web 请求
        wg.Add(1)
        go func(url string) {
            // 发送 GET 请求
            resp, err := http.Get(url)
            if err != nil {
                fmt.Printf("Error getting %s: %v\n", url, err)
            } else {
                fmt.Printf("Status code for %s: %d\n", url, resp.StatusCode)
            }

            // 例程完成，递减等待组计数
            wg.Done()
        }(url)
    }

    // 等待所有例程完成
    wg.Wait()
}

In the above code:

• We use sync.WaitGroup to track The number of outstanding routines.
• For each web request URL, we start a concurrent Go routine to send the request.
• The routine uses wg.Done() to indicate that it is done.
• The main program uses wg.Wait() to block until all routines are completed.

By using this method, we can send multiple web requests concurrently and continue executing the main program without waiting for the response of each request.

The above is the detailed content of How Golang functions efficiently handle parallel tasks. For more information, please follow other related articles on the PHP Chinese website!