Gleichzeitige Programmierkenntnisse: Fortgeschrittene Nutzung von Go WaitGroup

Tipps zur gleichzeitigen Programmierung: Erweiterte Verwendung von Go WaitGroup

Bei der gleichzeitigen Programmierung ist die Koordinierung und Verwaltung der Ausführung mehrerer gleichzeitiger Aufgaben eine wichtige Aufgabe. Die Go-Sprache bietet ein sehr praktisches Parallelitätsprimitiv – WaitGroup, das uns dabei helfen kann, die Parallelitätskontrolle elegant zu implementieren. In diesem Artikel wird die grundlegende Verwendung von WaitGroup vorgestellt und der Schwerpunkt auf die erweiterte Verwendung gelegt. Dabei werden spezifische Codebeispiele verwendet, um den Lesern zu helfen, sie besser zu verstehen und anzuwenden.

WaitGroup ist ein in die Go-Sprache integriertes Parallelitätsprimitiv, das uns helfen kann, auf den Abschluss gleichzeitiger Aufgaben zu warten. Es bietet drei Methoden: Hinzufügen, Fertig und Warten. Die Add-Methode wird verwendet, um die Anzahl der wartenden Aufgaben festzulegen, die Done-Methode wird verwendet, um die Anzahl der wartenden Aufgaben zu reduzieren, und die Wait-Methode wird verwendet, um die aktuelle Coroutine zu blockieren, bis alle wartenden Aufgaben abgeschlossen sind.

Hier ist ein einfaches Beispiel, das die grundlegende Verwendung von WaitGroup zeigt:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(num int) {
            defer wg.Done()

            time.Sleep(time.Second)
            fmt.Println("Task", num, "done")
        }(i)
    }

    wg.Wait()
    fmt.Println("All tasks done")
}

Im obigen Code erstellen wir ein WaitGroup-Objekt wg und erstellen 5 gleichzeitige Aufgaben durch eine Schleife. Während der Ausführung jeder Aufgabe verwenden wir die Add-Methode, um die Anzahl der wartenden Aufgaben zu erhöhen, und am Ende der Aufgabe verwenden wir die Done-Methode, um die Anzahl der wartenden Aufgaben zu reduzieren. Schließlich rufen wir die Wait-Methode auf, um die Haupt-Coroutine zu blockieren, bis alle wartenden Aufgaben abgeschlossen sind.

Zusätzlich zur grundlegenden Nutzung bietet WaitGroup auch einige erweiterte Nutzungsmöglichkeiten, mit denen die Ausführung gleichzeitiger Aufgaben flexibler gesteuert werden kann. Im Folgenden stellen wir einige häufig verwendete erweiterte Verwendungen im Detail vor.

1. Führen Sie eine Reihe von Aufgaben aus und legen Sie die maximale Anzahl von Parallelitäten fest.

Wenn wir eine Reihe von Aufgaben gleichzeitig ausführen müssen, aber die maximale Anzahl von Parallelitäten begrenzen möchten, können wir einen gepufferten Kanal in Kombination mit verwenden eine WaitGroup, um dies zu erreichen. Der folgende Code zeigt, wie eine Reihe von Aufgaben gleichzeitig ausgeführt werden, erlaubt jedoch nur die gleichzeitige Ausführung von maximal 3 Aufgaben:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    maxConcurrency := 3
    tasks := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    sem := make(chan struct{}, maxConcurrency)

    for _, task := range tasks {
        wg.Add(1)
        sem <- struct{}{} // 获取令牌，控制最大并发数

        go func(num int) {
            defer wg.Done()

            time.Sleep(time.Second)
            fmt.Println("Task", num, "done")

            <-sem // 释放令牌，允许新的任务执行
        }(task)
    }

    wg.Wait()
    fmt.Println("All tasks done")
}

Im obigen Code erstellen wir einen gepufferten Kanal SEM und legen seine Größe auf die maximale Anzahl fest von Parallelitäten. Bevor jede Aufgabe beginnt, erhalten wir ein Token über die Anweisung sem

2. Timeout steuert die Ausführung gleichzeitiger Aufgaben

Manchmal möchten wir die Ausführungszeit gleichzeitiger Aufgaben steuern und die Ausführung der Aufgabe beenden, wenn eine Zeitüberschreitung auftritt. Durch die Verwendung gepufferter Kanäle und Timer können wir diese Funktionalität einfach implementieren. Der folgende Code zeigt, wie man das Zeitlimit einer gleichzeitigen Aufgabe auf 3 Sekunden festlegt:

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    tasks := []int{1, 2, 3, 4, 5, 6, 7}

    timeout := 3 * time.Second
    done := make(chan struct{})

    for _, task := range tasks {
        wg.Add(1)

        go func(num int) {
            defer wg.Done()

            // 模拟任务执行时间不定
            time.Sleep(time.Duration(num) * time.Second)
            fmt.Println("Task", num, "done")

            // 判断任务是否超时
            select {
            case <-done:
                // 任务在超时前完成，正常退出
                return
            default:
                // 任务超时，向通道发送信号
                close(done)
            }
        }(task)
    }



    wg.Wait()
    fmt.Println("All tasks done")
}

Im obigen Code erstellen wir einen Kanal „Fertig“ und ermitteln, ob der Kanal während der Aufgabenausführung geschlossen ist, um festzustellen, ob die Aufgabe eine Zeitüberschreitung aufweist. Wenn eine Aufgabe abgeschlossen ist, verwenden wir die Anweisung close(done), um ein Signal an den Done-Kanal zu senden, um anzuzeigen, dass die Aufgabe abgelaufen ist. Wählen Sie mithilfe von Select-Anweisungen verschiedene Zweige aus, um unterschiedliche Situationen zu bewältigen.

Anhand des obigen Beispielcodes können wir sehen, dass die erweiterte Verwendung von WaitGroup in der tatsächlichen gleichzeitigen Programmierung sehr praktisch ist. Durch die Beherrschung dieser Techniken können wir die Ausführung gleichzeitiger Aufgaben besser steuern und die Leistung und Wartbarkeit des Codes verbessern. Ich hoffe, dass die Leser durch die Einführung und den Beispielcode dieses Artikels ein tiefes Verständnis für die Verwendung von WaitGroup erlangen und ihn dann auf tatsächliche Projekte anwenden können.

Das obige ist der detaillierte Inhalt vonGleichzeitige Programmierkenntnisse: Fortgeschrittene Nutzung von Go WaitGroup. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!