Comment contrôler le cycle de vie des coroutines Golang ?

Contrôler le cycle de vie d'une coroutine Go peut se faire des manières suivantes : Créer une coroutine : Utilisez le mot-clé go pour démarrer une nouvelle tâche. Terminez les coroutines : attendez que toutes les coroutines soient terminées, utilisez sync.WaitGroup. Utilisez les signaux de fermeture de canal. Utilisez le contexte context.Context.

Comment contrôler le cycle de vie des coroutines Go ?

Dans le langage Go, les coroutines (également appelées Goroutines) sont des organes d'exécution simultanés légers utilisés pour effectuer des tâches spécifiques sans bloquer le thread principal. La gestion du cycle de vie des coroutines est essentielle pour écrire du code parallèle robuste et maintenable.

Créer une coroutine

Utilisez le mot-clé go pour créer une coroutine. Il démarre une nouvelle tâche en arrière-plan afin que le thread principal puisse poursuivre son exécution. 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() // 取消上下文
}

Terminaison des coroutines

Impossible de terminer les coroutines directement, mais il existe les méthodes suivantes pour atteindre cet objectif indirectement :

Attendez que toutes les coroutines se terminent

Utilisez sync.WaitGroup pour synchroniser Tâche terminée : 🎜

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)
}

Utiliser le signal de fermeture du canal

🎜Utiliser le canal pour envoyer le signal "fermer" à la coroutine : 🎜rrreee

Utiliser le contexte

🎜Utiliser context.Context Gérer l'exécution de la coroutine Lorsque le contexte est annulé, la coroutine se terminera également : 🎜rrreee🎜Cas pratique🎜🎜Ce qui suit est un cas pratique utilisant le signal de fermeture de canal :🎜rrreee.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!