Bagaimana untuk menguruskan kitaran hayat Goroutine dalam Go?

Kaedah teras mengurus kitaran hayat Goroutine dalam Go adalah seperti berikut: Gunakan konteks.Konteks: Kawal kitaran hayat Goroutine melalui isyarat pembatalan dan tarikh akhir. Gunakan sync.WaitGroup: Tunggu Goroutine menyelesaikan tugasnya supaya Goroutine utama boleh meneruskan pelaksanaan. Gunakan saluran: selaraskan berbilang Goroutine melalui komunikasi isyarat dan tunggu pemprosesan seterusnya selepas semua Goroutine selesai.

Urus kitaran hayat Goroutine dalam Go

Goroutine ialah benang ringan dalam Go yang menyokong konkurensi. Pengurusan mereka adalah penting untuk mengelakkan kebocoran sumber dan ranap program. Artikel ini akan meneroka pelbagai kaedah mengurus kitaran hayat Goroutine, termasuk:

1 Menggunakan 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 menyediakan cara untuk mengurus Goroutine. Mekanisme kitaran hayat untuk menyebarkan isyarat pembatalan dan tarikh akhir. Untuk menggunakannya untuk mengurus kitaran hayat Goroutine, anda boleh menggunakan langkah berikut:

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 Gunakan sync.WaitGroup

🎜sync.WaitGroup untuk membenarkan. Goroutines untuk menunggu antara satu sama lain, sehingga mereka menyelesaikan tugas masing-masing. Gunakannya untuk mengurus kitaran hayat Goroutine Anda boleh menunggu dalam Goroutine utama untuk semua Goroutine kanak-kanak selesai. 🎜

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. Menggunakan saluran 🎜🎜🎜Saluran boleh berkomunikasi antara Goroutines dan juga boleh digunakan untuk menguruskan kitaran hayat mereka. Goroutine induk boleh menunggu semua goroutine kanak-kanak selesai dengan menghantar isyarat kepada saluran yang menandakan goroutine sebagai selesai. 🎜rreeee

Atas ialah kandungan terperinci Bagaimana untuk menguruskan kitaran hayat Goroutine dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!