So stoppen Sie Goroutine in Golang (vier Methoden)

Golang ist eine Sprache, die für die Erstellung einer hochgradig gleichzeitigen und effizienten Programmierung entwickelt wurde. Sie bietet einen praktischen und effizienten Goroutine-Mechanismus, der die Ausführungseffizienz und Leistung des Programms erheblich verbessern kann. Wenn wir Goroutine verwenden, müssen wir jedoch auf einige Dinge achten, z. B. darauf, wie wir die Ausführung von Goroutine stoppen können. Im Folgenden konzentrieren wir uns darauf, wie man Goroutine stoppt.

Die Grundlagen von Goroutine

Bevor wir verstehen, wie man Goroutine stoppt, müssen wir zunächst die Grundkenntnisse von Goroutine verstehen. Goroutine ist eine Implementierung von Lightweight-Threads in der Golang-Sprache und kann auf einem oder mehreren Threads ausgeführt werden. Es wird vom Go-Laufzeitsystem verwaltet und ist eine unabhängige, leichte Ausführungseinheit. Im Gegensatz zu herkömmlichen Threads wird Goroutine beim Ausführen automatisch vom Go-Laufzeitsystem geplant, und sein Planungsmodell ist auch sehr effizient. Es kann nicht nur eine hohe Parallelität gut unterstützen, sondern auch die Vorteile von Multi-Core-CPUs voll ausnutzen.

So erstellen Sie eine Goroutine

In der Go-Sprache können wir eine Goroutine auf die folgenden zwei gängigen Arten erstellen:

1. Mit dem Schlüsselwort go

go func() {
    //goroutine运行的代码
}()

2. Mit dem Schlüsselwort go und dem Funktionsnamen

func myFunc() {
    //goroutine运行的代码
}

go myFunc()

Wie Goroutine stoppen

Goroutine stoppen ist ein komplizierteres Problem, da Goroutine beim Ausführen keine expliziten Beendigungs- und Unterbrechungsmethoden bereitstellt. Dies liegt daran, dass eines der Designziele der Go-Sprache darin besteht, zu verhindern, dass Goroutinen während der Ausführung blockiert werden. Daher benötigen wir einige spezielle Techniken, um sie zu stoppen.

In der Go-Sprache gibt es die folgenden vier Möglichkeiten, Goroutine zu stoppen:

1. Die Verwendung von Channel

Die Verwendung von Channel ist eine der einfachsten und sichersten Möglichkeiten, Goroutine zu stoppen. Wir können einen Kanal vom Typ Bool erstellen, indem wir ein Signal an diesen Kanal senden. Nach dem Empfang des Signals kann die Goroutine normal beendet werden.

func worker(stopChan chan bool) {
    for {
        select {
        case <-stopChan:
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("worker is running")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    stopChan := make(chan bool)
    go worker(stopChan)
    time.Sleep(3 * time.Second)
    stopChan <- true
    time.Sleep(time.Second)
}

2. Kontext verwenden

In Go1.7 wurde das Kontextpaket zur Standardbibliothek hinzugefügt und bietet eine neue Methode zum Anhalten und Abbrechen von Goroutinen. Wir können in jeder Goroutine einen Kontextparameter übergeben und dann eine Abbruchoperation für diese Kontextvariable ausführen, wenn wir die Goroutine stoppen müssen.

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("worker is running")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)
    time.Sleep(3 * time.Second)
    cancel()
    time.Sleep(time.Second)
}

3. Verwenden Sie Mutex und WaitGroup, um das Stoppen von Goroutine über gemeinsam genutzte Variablen zu steuern. Diese Methode erfordert die Verwendung von Mutex und WaitGroup im Synchronisierungspaket. Mutex wird verwendet, um das Lesen und Schreiben von gemeinsam genutzten Variablen zu schützen, und WaitGroup wird verwendet, um auf den Abschluss aller Goroutinen zu warten.

var wg sync.WaitGroup
var stop bool
var mutex sync.Mutex

func worker() {
    defer wg.Done()
    for {
        mutex.Lock()
        if stop {
            mutex.Unlock()
            fmt.Println("worker stopped")
            return
        }
        fmt.Println("worker is running")
        mutex.Unlock()
        time.Sleep(time.Second)
    }
}

func main() {
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go worker()
    }
    time.Sleep(3 * time.Second)
    mutex.Lock()
    stop = true
    mutex.Unlock()
    wg.Wait()
    time.Sleep(time.Second)
}

4. Verwenden Sie das Laufzeitpaket. Die Methode zur Verwendung des Laufzeitpakets ist etwas problematischer. Im von der Goroutine ausgeführten Code müssen Sie die globalen Variablen regelmäßig überprüfen und die Goroutine dann stoppen , verwenden Sie die Funktion im Laufzeitpaket, um dessen Beendigung zu erzwingen.

var stop bool

func worker() {
    for {
        if stop {
            fmt.Println("worker stopped")
            return
        }
        fmt.Println("worker is running")
        time.Sleep(time.Second)
    }
}

func main() {
    go worker()
    time.Sleep(3 * time.Second)
    stop = true
    time.Sleep(time.Second)
    runtime.Goexit() //退出当前运行的goroutine
}

Zusammenfassung

Die Verwendung von Goroutine kann die Parallelitätsleistung des Programms erheblich verbessern, aber auch die Steuerung des Betriebs von Goroutine ist zu einem Problem geworden, dem wir uns stellen müssen. Die oben genannten vier Methoden haben ihre eigenen Vorteile und anwendbaren Szenarien, und Sie müssen entsprechend der spezifischen Situation die am besten geeignete Methode auswählen.

Das obige ist der detaillierte Inhalt vonSo stoppen Sie Goroutine in Golang (vier Methoden). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!