Wie Golang funktioniert, um parallele Aufgaben effizient zu bewältigen

Effiziente parallele Aufgabenbearbeitung in Go-Funktionen: Verwenden Sie das Schlüsselwort go, um gleichzeitige Routinen zu starten. Verwenden Sie sync.WaitGroup, um die Anzahl der ausstehenden Routinen zu zählen. Wenn die Routine abgeschlossen ist, wird wg.Done() aufgerufen, um den Zähler zu dekrementieren. Das Hauptprogramm blockiert mit wg.Wait(), bis alle Routinen abgeschlossen sind. Praktischer Fall: Webanfragen gleichzeitig senden und Antworten sammeln.

Effiziente parallele Aufgabenverarbeitung in Go-Funktionen

Die Go-Sprache bietet leistungsstarke Parallelverarbeitungsfunktionen, sodass Entwickler problemlos gleichzeitige Aufgaben erstellen und ausführen können. In diesem Artikel wird erläutert, wie Go-Funktionen zur effizienten Bearbeitung paralleler Aufgaben verwendet werden, und es wird ein praktischer Fall zur Demonstration der Verwendung bereitgestellt.

Parallelität in Go-Funktionen

Go-Funktionen bieten zwei Schlüsselwörter zur Unterstützung der gleichzeitigen Ausführung: go und sync.WaitGroup. Das Schlüsselwort go wird verwendet, um gleichzeitige Go-Routinen zu starten, während sync.WaitGroup verwendet wird, um auf den Abschluss aller Routinen zu warten. go 和 sync.WaitGroup。go 关键字用于启动并发的 Go 例程，而 sync.WaitGroup 用于等待所有例程完成。

等待组

sync.WaitGroup 是一个计数器，用于跟踪未完成例程的数量。当例程完成时，它会调用 wg.Done() 来递减计数器。主程序可以使用 wg.Wait() 方法来阻塞，直到所有例程完成。

实战案例：并发 Web 请求

考虑一个场景，我们需要并发发送多个 Web 请求并收集响应。以下是演示如何使用 Go 函数进行高效并发任务处理的代码：

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()
}

在上面的代码中：

• 我们使用 sync.WaitGroup 来跟踪未完成例程的数量。
• 对于每个 Web 请求 URL，我们启动一个并发的 Go 例程来发送请求。
• 例程使用 wg.Done() 来表示它已完成。
• 主程序使用 wg.Wait()

Wait Group

🎜sync.WaitGroup ist ein Zähler, der die Anzahl ausstehender Routinen verfolgt. Wenn die Routine abgeschlossen ist, ruft sie wg.Done() auf, um den Zähler zu dekrementieren. Das Hauptprogramm kann mit der Methode wg.Wait() blockieren, bis alle Routinen abgeschlossen sind. 🎜🎜🎜Praktischer Fall: Gleichzeitige Webanfragen🎜🎜🎜Stellen Sie sich ein Szenario vor, in dem wir mehrere Webanfragen gleichzeitig senden und Antworten sammeln müssen. Hier ist Code, der zeigt, wie Go-Funktionen für eine effiziente gleichzeitige Aufgabenverarbeitung verwendet werden: 🎜rrreee🎜 Im obigen Code: 🎜

• Wir verwenden sync.WaitGroup, um die Menge ausstehender Routinen zu verfolgen. 🎜
• Für jede Web-Anfrage-URL starten wir eine gleichzeitige Go-Routine, um die Anfrage zu senden. 🎜
• Die Routine verwendet wg.Done(), um anzuzeigen, dass der Vorgang abgeschlossen ist. 🎜
• Das Hauptprogramm verwendet wg.Wait(), um zu blockieren, bis alle Routinen abgeschlossen sind. 🎜🎜🎜Mit dieser Methode können wir mehrere Webanfragen gleichzeitig senden und das Hauptprogramm weiter ausführen, ohne auf die Antwort jeder Anfrage warten zu müssen. 🎜

Das obige ist der detaillierte Inhalt vonWie Golang funktioniert, um parallele Aufgaben effizient zu bewältigen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!