Comment gérer le cycle de vie de Goroutine dans Go ?

La méthode de base de gestion du cycle de vie de Goroutine dans Go est la suivante : Utiliser le contexte.Contexte : Contrôlez le cycle de vie de Goroutine via des signaux d'annulation et des délais. Utilisez sync.WaitGroup : attendez que le Goroutine termine sa tâche afin que le Goroutine principal puisse continuer son exécution. Utilisez des canaux : coordonnez plusieurs Goroutines via la communication par signal et attendez le traitement ultérieur une fois que toutes les Goroutines sont terminées.

Gérer le cycle de vie de Goroutine dans Go

Goroutine est un thread léger dans Go qui prend en charge la concurrence. Leur gestion est cruciale pour éviter les fuites de ressources et les plantages de programmes. Cet article explorera diverses méthodes de gestion du cycle de vie de Goroutine, notamment :

1. Utiliser context.Context context.Context

context.Context 提供了一种在 Goroutine 内传播取消和截止日期信号的机制。要使用它来管理 Goroutine 的生命周期，可以使用以下步骤：

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    go func() {
        // Goroutine 的代码
    }()

    // 等待 Goroutine 完成，或超时。
    select {
    case <-ctx.Done():
        fmt.Println("Goroutine 已取消或超时。")
    }
}

2. 使用 sync.WaitGroup

sync.WaitGroup

context.Context fournit un moyen de gérer Goroutine. cycle de vie Mécanismes de propagation des signaux d’annulation et de date limite. Pour l'utiliser pour gérer le cycle de vie de Goroutine, vous pouvez suivre les étapes suivantes :

package main

import (
    "fmt"
    "runtime"
    "sync"
)

func main() {
    wg := sync.WaitGroup{}

    // 创建 5 个子 Goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1) // 递增WaitGroup计数，表明正在等待另一个Goroutine完成

        go func(i int) {
            fmt.Printf("Goroutine %d 结束。\n", i)
            wg.Done() // 递减WaitGroup计数，表明Goroutine已完成
        }(i)
    }

    // 等待所有子 Goroutine 完成
    wg.Wait()

    fmt.Println("所有子 Goroutine 都已完成。")
}

2 Utilisez sync.WaitGroup

🎜sync.WaitGroup pour autoriser. Les Goroutines doivent s'attendre les uns les autres, jusqu'à ce qu'ils terminent leurs tâches respectives. Utilisez-le pour gérer le cycle de vie de Goroutine. Vous pouvez attendre dans le Goroutine principal que tous les Goroutines enfants soient terminés. 🎜

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    signals := make(chan struct{})

    // 创建 5 个子 Goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)

        go func(i int) {
            defer wg.Done() // Goroutine退出时递减WaitGroup计数

            // 等待其他Goroutine完成
            <-signals
            fmt.Printf("Goroutine %d 已完成。\n", i)
        }(i)
    }

    // 等待所有子 Goroutine完成
    wg.Wait()

    // 发送信号标记所有子Goroutine都已完成
    close(signals)

    fmt.Println("所有子 Goroutine 都已完成。")
}

🎜🎜3. Utiliser les canaux 🎜🎜🎜Les canaux peuvent communiquer entre les Goroutines et peuvent également être utilisés pour gérer leurs cycles de vie. Une goroutine maître peut attendre que toutes les goroutines enfants soient terminées en envoyant un signal à un canal qui marque la goroutine comme terminée. 🎜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!