Bagaimana untuk mengawal kitaran hidup coroutine Golang?

Mengawal kitaran hayat coroutine Go boleh dilakukan dengan cara berikut: Buat coroutine: Gunakan kata kunci go untuk memulakan tugas baharu. Tamatkan coroutine: tunggu semua coroutine selesai, gunakan sync.WaitGroup. Gunakan isyarat penutup saluran. Gunakan konteks konteks.Konteks.

Bagaimana untuk mengawal kitaran hayat coroutine Go?

Dalam bahasa Go, coroutines (juga dikenali sebagai Goroutines) ialah badan pelaksanaan serentak ringan yang digunakan untuk melaksanakan tugas tertentu tanpa menyekat utas utama. Menguruskan kitaran hayat coroutine adalah penting untuk menulis kod selari yang mantap dan boleh diselenggara.

Buat coroutine

Gunakan kata kunci go untuk membuat coroutine. Ia memulakan tugas baharu di latar belakang supaya utas utama boleh meneruskan pelaksanaan. 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() // 取消上下文
}

Penamatan coroutine

Tidak boleh menamatkan coroutine secara langsung, tetapi terdapat kaedah berikut untuk mencapai tujuan ini secara tidak langsung:

Tunggu sehingga semua coroutine selesai

Gunakan sync.WaitGroup untuk menyegerakkan Tugasan selesai: 🎜

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

Gunakan isyarat penutup saluran

🎜Gunakan saluran untuk menghantar isyarat "tutup" kepada coroutine: 🎜rrreee

Gunakan konteks

🎜Gunakan konteks.Konteks Uruskan pelaksanaan coroutine Apabila konteks dibatalkan, coroutine juga akan ditamatkan: 🎜rrreee🎜Kes praktikal🎜🎜Berikut ialah kes praktikal menggunakan isyarat penutup saluran:🎜rrreee

Atas ialah kandungan terperinci Bagaimana untuk mengawal kitaran hidup coroutine Golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!