Bagaimana golang melaksanakan operasi penutupan goroutine

Golang ialah bahasa pengaturcaraan yang elegan kerana ia menyediakan konkurensi yang mudah. Concurrency adalah teras kepada semua pembangunan perisian moden, membolehkan kami membina aplikasi yang sangat berskala, boleh diselenggara dan boleh dipercayai. Di Golang, sangat mudah untuk mencapai konkurensi melalui goroutine, tetapi penggunaan goroutine juga boleh menyebabkan beberapa masalah, yang paling biasa ialah cara melakukan operasi penutupan goroutine.

Dalam artikel ini, kami akan meneroka cara menutup gorouti di Golang dengan anggun. Kami akan memperkenalkan dua kaedah, satu adalah untuk menghantar isyarat untuk menutup dengan menggunakan saluran dan satu lagi adalah untuk membatalkan goroutine menggunakan fungsi WithCancel pakej konteks. Pada masa yang sama, kami juga akan meneroka bagaimana untuk mengelakkan masalah kebocoran goroutine.

Menutup goroutine menggunakan saluran

Mula-mula, mari kita lihat cara menggunakan saluran untuk menutup goroutine. Saluran adalah struktur asas yang digunakan untuk komunikasi di Golang. Saluran boleh digunakan bukan sahaja untuk memindahkan data, tetapi juga untuk memindahkan isyarat kawalan.

Kami boleh membuat saluran untuk mengawal penutupan goroutine. Kita boleh gelung dalam goroutine dan menunggu isyarat pada saluran Setelah isyarat diterima, goroutine akan keluar. Berikut ialah kod sampel:

package main

import (
    "fmt"
    "time"
)

func main() {
    quit := make(chan bool)

    go func() {
        for {
            select {
            case <-quit:
                fmt.Println("goroutine stopped")
                return
            default:
                fmt.Println("working...")
            }
            time.Sleep(1 * time.Second)
        }
    }()

    time.Sleep(5 * time.Second)
    fmt.Println("sending quit signal")
    quit <- true

    time.Sleep(2 * time.Second)
    fmt.Println("exiting program")
}

Dalam contoh di atas, kami mencipta saluran boolean bernama berhenti dan memulakan goroutine dalam fungsi utama. Gelung goroutine menunggu isyarat pada saluran, dan setelah isyarat diterima, goroutine akan keluar. Dalam fungsi utama, kami menunggu selama 5 saat dan kemudian menghantar nilai sebenar ke saluran untuk mencetuskan penutupan goroutine. Akhirnya, kami menunggu 2 saat untuk program keluar.

Gunakan konteks untuk membatalkan goroutine

Kami juga boleh menggunakan fungsi context.WithCancel untuk membatalkan goroutine Fungsi ini akan mengembalikan konteks (Konteks) dan fungsi pembatalan (CancelFunc). Konteks ialah jenis yang digunakan untuk menyampaikan maklumat kontekstual antara goroutine. Kami boleh menggabungkan Konteks dengan saluran untuk menutup goroutine dengan anggun. Berikut ialah kod sampel:

package main

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

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

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

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

    time.Sleep(2 * time.Second)
    fmt.Println("exiting program")
}

Dalam contoh di atas, kami menggunakan fungsi WithCancel dalam pakej konteks untuk mencipta konteks dan menggunakan konteks ini untuk memulakan goroutine. Gelung goroutine menunggu nilai pulangan fungsi Done() konteks untuk menyemak sama ada ia perlu keluar. Manfaat tambahan menggunakan konteks berbanding saluran ialah ia boleh digunakan untuk menghantar maklumat konteks (seperti ID permintaan, tamat masa, dsb.).

Elakkan kebocoran goroutine

Di Golang, kebocoran goroutine adalah masalah biasa. Ini berlaku apabila goroutine dibatalkan atau ditutup sebelum menyelesaikan tugasnya, atau ia kehabisan benang atau memori tanpa ditutup dengan betul.

Untuk mengelakkan kebocoran goroutine, kita perlu mempertimbangkan kitaran hayatnya sebelum mencipta goroutine. Kita perlu memastikan bahawa goroutine dapat dilepaskan dengan betul supaya ingatan dapat dituntut semula tepat pada masanya. Kita harus menggunakan saluran atau konteks untuk kawalan dan penyelarasan goroutine apabila boleh. Apabila goroutine tidak lagi diperlukan, kita harus menggunakan saluran atau konteks untuk menghantar isyarat untuk membiarkannya keluar secara automatik.

Ringkasan

Dalam artikel ini, kami memperkenalkan secara ringkas cara menutup gorouti di Golang dengan anggun. Kami telah meneroka dua pendekatan: menggunakan saluran dan menggunakan konteks. Pada masa yang sama, kami juga membincangkan bagaimana untuk mengelakkan masalah biasa kebocoran goroutine. Ini adalah topik yang sangat penting untuk setiap pembangun Golang kerana mengawal kitaran hayat gorouti dengan betul adalah sangat kritikal apabila menulis aplikasi konkurensi tinggi.

Atas ialah kandungan terperinci Bagaimana golang melaksanakan operasi penutupan goroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!