Cara menutup coroutine dalam golang

Dengan populariti Golang sejak beberapa tahun kebelakangan ini, semakin ramai yang mula memahami dan menggunakan Golang. Antaranya, coroutine ialah ciri utama bahasa Golang Pelaksanaan utasnya yang ringan menjadikan penggunaan coroutine sangat fleksibel dan cekap. Walau bagaimanapun, apabila menggunakan coroutine, kadangkala perlu menutup coroutine secara manual untuk melepaskan sumber dan mengelakkan masalah seperti kebocoran memori. Artikel ini akan memperkenalkan beberapa kaedah dan teknik untuk menutup coroutine di Golang.

1. Gunakan saluran untuk menutup coroutine

Di Golang, anda boleh menggunakan saluran untuk menutup coroutine. Kaedah ini sangat mudah. ​​Anda hanya perlu menentukan saluran jenis bool untuk mengawal penutupan coroutine dan terus mengesan status saluran ini dalam coroutine. Apabila saluran ditutup, coroutine akan keluar.

Berikut ialah contoh kod:

package main

import (
    "fmt"
    "time"
)

func worker(stop chan bool) {
    for {
        select {
        case <-stop:
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("working...")
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    stop := make(chan bool)
    go worker(stop)

    time.Sleep(5 * time.Second)
    fmt.Println("stop worker")
    close(stop)

    time.Sleep(5 * time.Second)
    fmt.Println("program exited")
}

Dalam kod di atas, kami mentakrifkan fungsi pekerja sebagai coroutine dan lulus dalam saluran jenis stop chan bool. Dalam fungsi pekerja, kami menggunakan pernyataan pilih untuk mendengar saluran berhenti Jika saluran ditutup, keluar dari coroutine. Dalam fungsi utama, kami mencipta saluran berhenti dan memulakan coroutine pekerja melalui kata kunci go. Selepas menunggu selama 5 saat, kami menutup saluran berhenti dalam fungsi utama, dengan itu menghentikan coroutine pekerja. Selepas penantian terakhir selama 5 saat, program keluar.

2. Gunakan konteks untuk membatalkan coroutine

Selain menggunakan saluran, konteks juga boleh digunakan di Golang untuk membatalkan coroutine. Konteks menyediakan kaedah standard yang membenarkan lulus masa tamat, isyarat pembatalan dan nilai lain pada skop permintaan coroutine yang sedang berjalan.

Berikut ialah contoh kod:

package main

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

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker canceled")
            return
        default:
            fmt.Println("working...")
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)

    time.Sleep(5 * time.Second)
    fmt.Println("cancel worker")
    cancel()

    time.Sleep(5 * time.Second)
    fmt.Println("program exited")
}

Dalam kod di atas, kami menggunakan fungsi context.WithCancel untuk mencipta konteks dengan isyarat pembatalan dan menghantarnya ke dalam fungsi pekerja. Dalam fungsi pekerja, kami menggunakan pernyataan pilih untuk mendengar saluran konteks.Selesai() Jika konteks dibatalkan, keluar dari coroutine. Dalam fungsi utama, kami memanggil fungsi batal untuk membatalkan konteks dan dengan itu menghentikan coroutine pekerja.

3. Gunakan sync.WaitGroup untuk melaksanakan coroutine waiting

Di Golang, menggunakan sync.WaitGroup untuk melaksanakan coroutine waiting juga merupakan kaedah biasa. Apabila coroutine bermula, kaunter WaitGroup akan dinaikkan sebanyak 1; apabila coroutine keluar, kaunter akan dikurangkan sebanyak 1. Apabila kaunter mencapai 0, ia menunjukkan bahawa semua coroutine telah keluar dan fungsi utama boleh meneruskan pelaksanaan.

Berikut ialah contoh kod:

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(wg *sync.WaitGroup, stop chan bool) {
    defer wg.Done()

    for {
        select {
        case <-stop:
            fmt.Println("worker stopped")
            return
        default:
            fmt.Println("working...")
            time.Sleep(1 * time.Second)
        }
    }
}

func main() {
    wg := sync.WaitGroup{}
    stop := make(chan bool)

    wg.Add(1)
    go worker(&wg, stop)

    time.Sleep(5 * time.Second)
    fmt.Println("stop worker")
    stop <- true

    wg.Wait()
    fmt.Println("program exited")
}

Dalam kod di atas, kami menggunakan sync.WaitGroup untuk menunggu keluar coroutine pekerja. Dalam fungsi pekerja, kami menggunakan pernyataan tangguh untuk mengurangkan kaunter WaitGroup apabila coroutine keluar. Dalam fungsi utama, kami mula-mula meningkatkan kaunter WaitGroup sebanyak 1, dan kemudian memanggil kata kunci pergi untuk memulakan coroutine pekerja. Selepas menunggu selama 5 saat, kami menghantar mesej jenis bool ke saluran berhenti untuk menghentikan coroutine pekerja. Akhirnya, kami menunggu kaunter WaitGroup menjadi 0, sekali gus menamatkan program.

Ringkasnya, artikel ini memperkenalkan beberapa kaedah menutup coroutine di Golang, termasuk menggunakan saluran untuk menutup coroutine, menggunakan konteks untuk membatalkan coroutine dan menggunakan sync.WaitGroup untuk melaksanakan coroutine waiting. Dalam projek sebenar, adalah perlu untuk memilih kaedah yang sesuai untuk menutup coroutine berdasarkan senario perniagaan dan keperluan khusus untuk mengelakkan kebocoran sumber dan meningkatkan prestasi program.

Atas ialah kandungan terperinci Cara menutup coroutine dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!