Bagaimana untuk menutup benang dengan betul dalam program golang

Apabila menulis program Golang, adalah perkara biasa untuk menggunakan pengaturcaraan serentak. Mekanisme goroutine Golang membolehkan pembangun membuat program serentak dengan mudah, tetapi jika goroutine digunakan secara tidak betul, ia akan menyebabkan masalah seperti kebocoran memori dan pembaziran sumber dalam program. Oleh itu, menutup goroutine dengan betul adalah cara yang diperlukan untuk memastikan kestabilan program.

Artikel ini akan membincangkan cara menutup goroutine dalam program Golang dengan betul.

Memahami goroutine

Di Golang, goroutine ialah benang ringan yang berjalan pada urutan sistem pengendalian dan boleh dijadualkan pada urutan berbeza pada bila-bila masa. Berbanding dengan benang tradisional, gorouti lebih ringan dan mempunyai lebih sedikit overhed untuk dicipta dan dimusnahkan.

Di Golang, kita boleh memulakan goroutine melalui kata kunci go, contohnya:

go func() {
    // do something
}()

Kitaran hayat goroutine yang dimulakan dengan cara ini dikawal oleh sistem masa jalan Golang . Apabila tugas goroutine selesai, pemungut sampah akan menuntut semula ruang memori yang didudukinya secara automatik.

Tutup goroutine dengan segera

Kadangkala, kita perlu menutup goroutine serta-merta tanpa menunggu ia selesai, contohnya:

func task() {
    for {
        // do something
    }
}

func main() {
    go task()

    // do other things

    // 关闭task
    // ???
}

Dalam kod di atas, kita mulakan A goroutine yang menjalankan tugas, tetapi apabila program perlu keluar, kami mahu dapat menutup goroutine dengan segera untuk mengelakkan kebocoran sumber.

Memandangkan goroutine Golang tidak menyediakan kaedah langsung untuk menutupnya, kami perlu melakukan beberapa pemprosesan sendiri. Pendekatan biasa ialah menggunakan saluran untuk mengawal penutupan goroutine.

Dalam fungsi tugas, kita boleh menerima saluran sebagai parameter dan menghantar isyarat kepada saluran untuk menunjukkan penutupan goroutine. Contohnya:

func task(quit chan bool) {
    for {
        select {
        case <- quit:
            return
        default:
            // do something
        }
    }
}

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

    // do other things

    // 关闭task
    quit <- true
}

Dalam kod di atas, kami menggunakan mekanisme pilih dalam fungsi tugasan untuk menunggu Apabila isyarat penutupan saluran berhenti diterima, fungsi akan keluar serta-merta. Dalam fungsi utama, kami mencipta saluran berhenti dan menyampaikannya sebagai parameter kepada fungsi tugas. Apabila kita perlu menutup goroutine, hanya hantar nilai sebenar ke saluran berhenti.

Tutup goroutine dengan anggun

Dalam proses pembangunan sebenar, kita bukan sahaja perlu memastikan goroutine ditutup serta-merta, tetapi juga memastikan bahawa goroutine boleh ditutup dengan anggun, iaitu, ia boleh menyelesaikan apa yang sedang dilaksanakan sebelum menutup Tugas. Contohnya:

func task() {
    for {
        // do something
    }
}

func main() {
    quit := make(chan bool)
    go func() {
        for {
            select {
            case <- quit:
                // 执行清理操作
                // ...

                // 退出goroutine
                return
            default:
                // do something
            }
        }
    }()

    // do other things

    // 关闭task
    quit <- true
}

Dalam kod di atas, kami memulakan goroutine, yang mendengar isyarat penutup saluran keluar melalui mekanisme pilih. Apabila isyarat dekat diterima, ia melakukan operasi pembersihan seperti menutup fail terbuka, menutup sambungan pangkalan data, dsb. Akhirnya, ia keluar dari goroutine, memastikan bahawa goroutine ditutup dengan baik.

mekanisme sync.WaitGroup

Selain menggunakan saluran untuk mengawal penutupan goroutin, Golang juga menyediakan mekanisme penyegerakan.WaitGroup untuk memastikan perintah pelaksanaan dan susunan penutupan goroutin. Contohnya:

func task(wg *sync.WaitGroup) {
    defer wg.Done()

    for {
        // do something
    }
}

func main() {
    var wg sync.WaitGroup

    wg.Add(1)
    go task(&wg)

    // do other things

    // 关闭task
    wg.Wait()
}

Dalam kod di atas, kami mencipta pembolehubah jenis penyegerakan.WaitGroup dan gunakan kaedah Tambah untuk meningkatkan pembilang goroutine. Dalam fungsi tugas, kami menggunakan pernyataan tangguh untuk memastikan kaedah Selesai dipanggil selepas tugasan selesai, mengurangkan nilai pembilang. Akhir sekali, gunakan kaedah Tunggu dalam fungsi utama untuk menunggu semua goroutine menyelesaikan tugas mereka.

Gunakan mekanisme penyegerakan.WaitGroup untuk menutup goroutine dengan anggun, memastikan semua tugasan dapat diselesaikan sebelum keluar.

Ringkasan

Dalam program Golang, menutup goroutine dengan betul adalah cara yang diperlukan untuk memastikan kestabilan program. Melalui mekanisme saluran atau penyegerakan.WaitGroup, kami boleh mengawal susunan penutup goroutine untuk memastikan semua tugasan dapat diselesaikan sebelum keluar. Apabila menggunakan goroutine, pembangun perlu memberi perhatian kepada isu seperti kebocoran memori dan pembaziran sumber untuk memastikan keteguhan dan kecekapan program.

Atas ialah kandungan terperinci Bagaimana untuk menutup benang dengan betul dalam program golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!