Wie kann der Lebenszyklus von Golang-Coroutinen gesteuert werden?

Die Steuerung des Lebenszyklus einer Go-Coroutine kann auf folgende Weise erfolgen: Erstellen Sie eine Coroutine: Verwenden Sie das Schlüsselwort go, um eine neue Aufgabe zu starten. Coroutinen beenden: Warten Sie, bis alle Coroutinen abgeschlossen sind, und verwenden Sie sync.WaitGroup. Verwenden Sie Kanalschließsignale. Verwenden Sie context context.Context.

Wie kontrolliere ich den Lebenszyklus von Go-Coroutinen?

In der Go-Sprache sind Coroutinen (auch als Goroutinen bekannt) leichte, gleichzeitig ausgeführte Körper, die zur Ausführung bestimmter Aufgaben verwendet werden, ohne den Hauptthread zu blockieren. Die Verwaltung des Lebenszyklus von Coroutinen ist entscheidend für das Schreiben von robustem und wartbarem Parallelcode.

Erstellen Sie eine Coroutine.

Verwenden Sie das Schlüsselwort go, um eine Coroutine zu erstellen. Es startet eine neue Aufgabe im Hintergrund, damit der Hauptthread die Ausführung fortsetzen kann. go 关键字创建协程。它在后台启动一个新的任务，使主线程可以继续执行。

go func() {
    // 执行任务
}

终止协程

无法直接终止协程，但有以下方法可以间接达到此目的：

等待所有协程完成

使用 sync.WaitGroup 同步任务完成：

import "sync"

var wg sync.WaitGroup

func main() {
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            // 执行任务
            wg.Done()
        }(i)
    }
    wg.Wait()
}

使用通道关闭信号

使用通道向协程发送"关闭"信号：

func main() {
    done := make(chan struct{})
    for i := 0; i < 5; i++ {
        go func(i int) {
            for {
                select {
                case <-done:
                    return // 协程停止
                default:
                    // 执行任务
                }
            }
        }(i)
    }
    close(done) // 向所有协程发送"关闭"信号
}

使用上下文

使用 context.Context

import "context"

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    for i := 0; i < 5; i++ {
        go func(i int) {
            for {
                select {
                case <-ctx.Done():
                    return // 协程停止
                default:
                    // 执行任务
                }
            }
        }(i)
    }
    cancel() // 取消上下文
}

Beendigung von Coroutinen

Coroutinen können nicht direkt beendet werden, aber es gibt die folgenden Methoden, um diesen Zweck indirekt zu erreichen:

Warten Sie, bis alle Coroutinen abgeschlossen sind

Verwenden Sie sync.WaitGroup zum Synchronisieren Aufgabe abgeschlossen: 🎜

package main

import "fmt"
import "time"

func main() {
    // 使用信道告诉协程何时退出
    stop := make(chan struct{})

    // 创建 5 个协程
    for i := 0; i < 5; i++ {
        go func(i int) {
            for {
                // 检查是否已经收到退出信号
                select {
                case <-stop:
                    fmt.Printf("协程 %d 已退出\n", i)
                    return
                default:
                    fmt.Printf("协程 %d 正在运行\n", i)
                    time.Sleep(time.Second)
                }
            }
        }(i)
    }

    // 运行 5 秒，然后发送退出信号
    time.Sleep(time.Second * 5)
    close(stop)

    // 等待所有协程退出
    time.Sleep(time.Second * 1)
}

Kanal-Schließsignal verwenden

🎜Kanal verwenden, um „Schließ“-Signal an Coroutine zu senden: 🎜rrreee

Kontext verwenden

🎜context.Context verwenden Verwalten Sie die Ausführung der Coroutine. Wenn der Kontext abgebrochen wird, wird die Coroutine ebenfalls beendet: 🎜rrreee🎜Praktischer Fall🎜🎜Das Folgende ist ein praktischer Fall, bei dem das Kanalschließsignal verwendet wird:🎜rrreee

Das obige ist der detaillierte Inhalt vonWie kann der Lebenszyklus von Golang-Coroutinen gesteuert werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!