So beenden Sie die Golang-Coroutine

Golang ist eine sehr beliebte Programmiersprache und ihre Goroutine ist eines ihrer ikonischen Merkmale. Der Vorteil von Goroutine besteht darin, dass es problemlos Parallelität implementieren kann, wodurch Golang bei der Bewältigung von Szenarien mit hoher Parallelität eine gute Leistung erbringt. Aber wie beenden wir Goroutinen korrekt, wenn wir sie verwenden? In diesem Artikel befassen wir uns mit den Exit-Methoden von Goroutine.

1. Verwenden Sie die Kanalsteuerung

Die Verwendung des Kanals ist eine der Möglichkeiten, Goroutine in Golang zu verlassen. Steuern Sie, ob Goroutine beendet wird, indem Sie einen Kanal vom Typ Bool erstellen. Nachdem die Goroutine-Ausführung beendet ist, können wir die Goroutine zum Beenden auffordern, indem wir einen Wert vom Typ Bool in den Kanal schreiben.

Der Beispielcode lautet wie folgt:

package main

import (
   "fmt"
)

func goroutine(ch chan bool) {
   for {
      select {
         case <-ch:
            fmt.Println("goroutine exit")
            return
         default:
            fmt.Println("goroutine running")
      }
   }
}

func main() {
   ch := make(chan bool)
   go goroutine(ch)
   fmt.Println("main thread")
   ch <- true
}

Im obigen Code haben wir eine goroutine()-Funktion erstellt, die in einer Schleife ausgeführt wird. In der Funktion main() erstellen wir einen Kanal vom Typ Bool und übergeben ihn an die Funktion goroutine(). In der Goroutine-Funktion verwenden wir die Select-Anweisung, um zu erkennen, ob ein Wert in den Kanal geschrieben wird. Wenn ein Wert geschrieben wird, wird die Exit-Operation ausgeführt.

In der Funktion main() verwenden wir die Anweisung ch <- true, um einen Wert vom Typ Bool in den Kanal zu schreiben, der den Exit-Vorgang in der Goroutine-Funktion auslöst.

Indem wir Kanäle verwenden, um den Ausgang von Goroutine zu kontrollieren, können wir Goroutine elegant stoppen.

2. Verwenden Sie das Kontextpaket

Zusätzlich zur Verwendung von Kanälen zur Steuerung des Goroutine-Exits stellt Golang auch das Kontextpaket zur Implementierung des Goroutine-Exits bereit. Das Kontextpaket stellt einen Kontexttyp bereit, der zum Übertragen von Informationen zwischen verschiedenen Goroutinen verwendet werden kann, einschließlich der Angabe von Goroutine-Timeout, Abbruch und anderen Vorgängen.

In Goroutine können wir die WithContext()-Methode des Kontextpakets verwenden, um ein Objekt vom Typ Context zu erstellen, und dann die WithCancel()-Methode verwenden, um das Context-Objekt abzubrechen:

package main

import (
   "fmt"
   "context"
)

func goroutine(ctx context.Context) {
   for {
      select {
         case <-ctx.Done():
            fmt.Println("goroutine exit")
            return
         default:
            fmt.Println("goroutine running")
      }
   }
}

func main() {
   ctx, cancel := context.WithCancel(context.Background())
   go goroutine(ctx)
   fmt.Println("main thread")
   cancel()
}

Im obigen Code verwenden wir zuerst WithContext ()-Methode erstellt ein Objekt ctx vom Typ Context und verwendet dann die Methode WithCancel(), um eine Funktion cancel zum Abbrechen des ctx-Objekts zu erstellen. In der Funktion goroutine() verwenden wir die SELECT-Anweisung, um die Done()-Methode des ctx-Objekts zu überwachen. Wenn diese Methode ausgelöst wird, bedeutet dies, dass die Goroutine beendet werden muss und den Exit-Vorgang ausführen muss.

In der Funktion main() haben wir zuerst die Methode WithContext() aufgerufen, um das Kontextobjekt ctx zu erstellen, und dann das Objekt an die Funktion goroutine() übergeben. Als nächstes rufen wir die Funktion cancel() auf, die sofort den Exit-Vorgang in der Funktion goroutine() auslöst.

Durch die Verwendung des Kontextpakets können wir Goroutine eleganter stoppen.

Fazit

In diesem Artikel haben wir ausführlich vorgestellt, wie man die Golang-Coroutine richtig beendet. Durch die Verwendung des Kanal- oder Kontextpakets können wir die Goroutine ordnungsgemäß stoppen. In der tatsächlichen Entwicklung hängt die Wahl der Methode von der jeweiligen Situation ab. Unabhängig von der Methode sollten wir jedoch den Entwurfsprinzipien der Golang-Sprache folgen und den Exit-Vorgang elegant handhaben, um sicherzustellen, dass unser Programm immer stabil und zuverlässig bleibt.

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