Cara menutup goroutine dalam golang (tiga kaedah)

Gorutin Golang ialah salah satu daripada mekanisme serentak yang berkuasa. Kelebihan goroutine ialah ia ringan, cekap, dan mudah dibuat dan dikawal. Tetapi pada masa yang sama, bagaimana untuk menutup goroutine secara munasabah adalah isu yang sangat penting.

Mengapa kita perlu menutup goroutine?

Penciptaan goroutine adalah sangat mudah, tetapi penggunaan yang tidak munasabah akan menyebabkan pembaziran sumber, terutamanya untuk goroutine yang berjalan lama. Jika goroutine terus berjalan sehingga program tamat, sumber sistem akan diduduki, yang boleh menyebabkan program ranap dan menjejaskan prestasi sistem.

Jadi, kita perlu tutup goroutine. Biasanya, sebab mengapa goroutine perlu ditutup adalah:

1. Groutine perlu ditutup apabila program keluar.
2. goroutine perlu ditutup selepas pelaksanaan untuk mengelakkan pembaziran sumber sistem.
3. Groutine perlu ditutup apabila ralat berlaku.

Bagaimana untuk menutup goroutine?

Bahasa GO menyediakan berbilang mekanisme untuk menutup goroutine:

1. Gunakan saluran

Anda boleh menggunakan saluran untuk menutup goroutine. Buat saluran, dan apabila goroutine perlu ditutup, hantar data ke saluran Selepas goroutine membaca data, ia boleh keluar seperti biasa. Contohnya:

func worker(stopCh chan struct{}) {
    for {
        select {
            // do something...
            case <-stopCh:
                return
        }
    }
}

stopCh := make(chan struct{})
go worker(stopCh)

// 关闭 goroutine
close(stopCh)

2. Gunakan konteks

Pakej konteks menyediakan cara yang lebih elegan untuk menutup goroutine. Anda boleh mencipta konteks.Konteks dan gunakan fungsi WithCancel atau WithTimeout untuk membatalkan konteks apabila perlu untuk menutup goroutine. Contohnya:

func worker(ctx context.Context) {
    for {
        select {
            // do something...
            case <-ctx.Done():
                return
        }
    }
}

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

// 关闭 goroutine
cancel()

3. Gunakan penyegerakan.WaitGroup

Pakej penyegerakan menyediakan WaitGroup, yang boleh menunggu sehingga goroutine selesai. Anda boleh menambah kaedah Selesai yang dipanggil pada penghujung pelaksanaan goroutine. Jika semua goroutine telah selesai dilaksanakan, anda boleh menggunakan Tunggu untuk menyekat penantian. Contohnya:

func worker(wg *sync.WaitGroup) {
    defer wg.Done()
    // do something...
}

var wg sync.WaitGroup
wg.Add(1)
go worker(&wg)

// 等待 goroutine 执行结束
wg.Wait()

Nota menutup goroutine

1. Jangan tutup goroutine terus

Biasanya, jangan tutup goroutine terus, jika tidak, ia mungkin Masalah seperti kebocoran sumber dan keadaan perlumbaan berlaku. Anda perlu menggunakan saluran, konteks atau WaitGroup untuk menutup goroutine.

2. Reka bentuk goroutine boleh ditutup

Apabila mereka bentuk goroutine, sebaiknya reka bentuknya supaya boleh ditutup. Jika goroutine yang berjalan lama direka bentuk untuk tidak boleh ditutup, ia mungkin tidak boleh ditutup, menyebabkan masalah. Oleh itu, ketahui perkara ini apabila menulis kod dan menggunakan goroutine.

3. Gunakan sumber sistem dengan berhati-hati

Sumber sistem adalah terhad, dan terlalu banyak goroutine mungkin menduduki terlalu banyak sumber sistem, sekali gus menjejaskan prestasi sistem. Oleh itu, apabila menggunakan goroutine, pastikan anda menggunakan sumber sistem dengan berhati-hati dan pastikan ia dikeluarkan dengan betul.

Ringkasan

Goroutine adalah kemuncak di Golang kerana ia ringan, cekap dan mudah digunakan. Walau bagaimanapun, ciri ini juga perlu digunakan dengan berhati-hati. Menutup goroutine dengan betul adalah kemahiran yang mesti dikuasai dalam pembangunan Golang. Kita boleh menggunakan mekanisme seperti saluran, konteks atau WaitGroup untuk menutup goroutine untuk mengelakkan kebocoran sumber dan masalah lain.

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