Die Golang-Coroutine wird geschlossen

In der Go-Sprache ist Coroutine ein wichtiger Mechanismus für die gleichzeitige Programmierung. Es ermöglicht die parallele Ausführung mehrerer Aufgaben und verbessert so die Programmeffizienz. Die Coroutine-Implementierung der Go-Sprache basiert auf leichtgewichtigen Threads (oder Threads auf Benutzerebene), sodass die Kosten für das Erstellen und Zerstören von Coroutinen sehr gering sind. In der tatsächlichen Entwicklung müssen wir jedoch manchmal die laufende Coroutine schließen, und in diesem Fall müssen wir spezielle Mittel verwenden, um dies zu erreichen. In diesem Artikel werden einige Methoden und Techniken zum Schließen von Golang-Coroutinen vorgestellt.

1. Die Natur von Coroutinen

Bevor wir die Methode zum Schließen von Coroutinen verstehen, müssen wir zunächst die Natur von Coroutinen verstehen. Eine Coroutine ist im Wesentlichen ein unabhängiger Ausführungsthread, der parallel zum Hauptthread ausgeführt wird. Jede Coroutine verfügt über einen eigenen Stapel und lokale Variablen, sie nutzen jedoch denselben Prozess und dieselben globalen Variablen. Das Erstellen und Zerstören von Coroutinen erfordert nur wenige Anweisungen und ist daher sehr effizient.

2. So schließen Sie die Coroutine

1. Schließen Sie die Coroutine über context.Context

In der Go-Sprache können Sie context.Context verwenden, um die Ausführung der Coroutine zu steuern. Ein Kontext mit Abbruchfunktion kann über die Funktion context.WithCancel erstellt werden. Wenn die Funktion Abbrechen des Kontexts aufgerufen wird, werden alle vom Kontext abhängigen Coroutinen geschlossen. Hier ist ein einfacher Beispielcode:

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go func() {
        for {
            select {
            case <-ctx.Done():
                log.Println("The goroutine is stopped.")
                return
            default:
                // do something
            }
        }
    }()
    time.Sleep(time.Second)
    cancel()
    time.Sleep(time.Second)
}

In diesem Beispiel erstellen wir einen Kontext mit einer Abbruchfunktion und erstellen eine Coroutine, in der bestimmte Operationen kontinuierlich ausgeführt werden, bis der Kontext abgebrochen wird. Warten Sie eine Sekunde im Hauptthread und rufen Sie dann die Funktion „Abbrechen“ von Context auf, um die Coroutine zu schließen.

2. Schließen Sie die Coroutine über den Kanal

Zusätzlich zur Verwendung von context.Context zur Steuerung der Ausführung der Coroutine können Sie auch Kanäle zur Implementierung verwenden. Normalerweise können wir einen Kanal vom Typ Bool erstellen, um das Signal zu übergeben, ob die Coroutine geschlossen werden soll. Wenn der Hauptthread die Schließfunktion des Kanals aufruft, erhalten alle Coroutinen, die den Kanal lesen, ein Nullwertsignal und werden beendet. Das Folgende ist ein Beispielcode:

func main() {
    stopCh := make(chan bool)
    go func() {
        for {
            select {
            case <-stopCh:
                log.Println("The goroutine is stopped.")
                return
            default:
                // do something
            }
        }
    }()
    time.Sleep(time.Second)
    close(stopCh)
    time.Sleep(time.Second)
}

In diesem Beispiel erstellen wir einen Kanal vom Typ Bool, um das Signal zu übergeben, ob die Coroutine geschlossen werden soll. Verwenden Sie in der Coroutine die Select-Anweisung, um kontinuierlich zu prüfen, ob der Kanal geschlossen ist, und wenn er geschlossen ist, beenden Sie ihn. Warten Sie eine Sekunde im Hauptthread und rufen Sie dann die Schließfunktion des Kanals auf, um die Coroutine zu schließen.

3. Schließen Sie die Coroutine über sync.WaitGroup

Zusätzlich zur Verwendung von context.Context und Kanal zur Steuerung der Ausführung der Coroutine können Sie auch sync.WaitGroup verwenden. WaitGroup ist ein Zähler, mit dem auf das Ende einer Gruppe von Coroutinen gewartet werden kann. Insbesondere wird beim Erstellen der Coroutine der Zähler der WaitGroup um eins erhöht, und nach der Ausführung der Coroutine wird der Zähler um eins dekrementiert. Rufen Sie im Hauptthread die Wait-Funktion von WaitGroup auf, um zu warten, bis die Ausführung aller Coroutinen abgeschlossen ist, und schließen Sie dann das Programm. Hier ist ein Beispielcode:

func main() {
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        for {
            // do something
        }
    }()
    time.Sleep(time.Second)
    wg.Done()
    wg.Wait()
}

In diesem Beispiel erstellen wir eine WaitGroup und erhöhen den Zähler um eins. Führen Sie in der Coroutine bestimmte Vorgänge aus, warten Sie auf das Ende der Coroutine und rufen Sie die Done-Funktion von WaitGroup auf, um den Zähler um eins zu verringern. Warten Sie eine Sekunde im Hauptthread, bevor Sie die Done-Funktion der WaitGroup aufrufen, und rufen Sie dann die Wait-Funktion auf, um zu warten, bis die Ausführung aller Coroutinen abgeschlossen ist, und schließen Sie dann das Programm.

3. Zusammenfassung

Coroutine in der Go-Sprache ist ein sehr leistungsfähiger gleichzeitiger Programmiermechanismus und wird häufig in der Entwicklung verwendet. In der tatsächlichen Entwicklung müssen wir jedoch manchmal die laufende Coroutine schließen, und in diesem Fall müssen wir spezielle Mittel verwenden, um dies zu erreichen. In diesem Artikel werden einige Methoden und Techniken zum Schließen von Golang-Coroutinen vorgestellt. Ich hoffe, dass er für alle hilfreich ist.

Das obige ist der detaillierte Inhalt vonDie Golang-Coroutine wird geschlossen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!