Saluran Golang ditutup

Semasa proses pembangunan, kita sering perlu menggunakan saluran Golang Apabila kita menggunakan saluran untuk menyelesaikan tugas, kita perlu menutup saluran tepat pada masanya untuk mengelakkan penyekatan, dengan itu mencapai kesan pengoptimuman program.

Jadi, dalam keadaan apakah anda perlu menutup saluran? Bagaimana untuk menutup saluran dengan betul? Di Golang, penutupan saluran sememangnya topik yang agak kompleks Mari kita terokai topik ini di bawah.

1. Mengapa anda perlu menutup saluran?

Pertama sekali, perlu jelas bahawa saluran tidak perlu ditutup dengan kata lain, Golang akan menutup saluran secara automatik apabila penunjuk terakhir ke saluran dimusnahkan. Tetapi tidak menutup saluran akan menyebabkan masalah berikut:

1. Memori bocor. Saluran yang tidak ditutup akan sentiasa menduduki memori, menunggu data dihantar atau diterima, menyebabkan kebocoran memori.
2. Sekat. Saluran yang tidak ditutup akan sentiasa menunggu data dihantar atau diterima Jika masa menunggu terlalu lama, program mungkin disekat.
3. Tidak dapat mengeluarkan sumber dalam masa. Dalam sesetengah senario, kita perlu menggunakan saluran untuk menyelaraskan operasi berbilang goroutin Jika saluran tidak ditutup dalam masa, sumber mungkin tidak dikeluarkan tepat pada masanya, sekali gus menjejaskan kecekapan menjalankan program.

2. Bagaimana hendak menutup saluran dengan betul?

Sekarang kita tahu kenapa kita perlu menutup saluran, bagaimana kita menutup saluran dengan betul? Malah, Golang menyediakan dua cara untuk menutup saluran:

1. Gunakan fungsi close()

Cara paling mudah dan biasa untuk menutup saluran ialah menggunakan tutup disediakan oleh fungsi Golang (). Format sintaks fungsi ini adalah seperti berikut:

close(channel)

Fungsi ini perlu lulus dalam parameter jenis saluran Apabila parameter jenis saluran yang diluluskan ditutup, ia tidak boleh dihantar atau diterima semula, jika tidak, ia akan menyebabkan panik .

2. Gunakan gelung julat untuk menutup saluran

Cara kedua yang biasa digunakan untuk menutup saluran ialah menggunakan gelung julat untuk, yang berguna untuk menerima nilai daripada saluran yang agak biasa. Untuk operasi menghantar data ke saluran, kaedah ini jarang digunakan untuk menutup saluran. Contoh kod menggunakan gelung julat for untuk menutup saluran adalah seperti berikut:

for val := range channel {
    fmt.Println(val)
}

// channel被关闭后，上述代码会正常退出循环

Dalam gelung julat untuk, apabila saluran ditutup, gelung akan tamat secara automatik. Perlu diingat bahawa jika kita menggunakan pernyataan seperti putus atau teruskan dalam gelung julat untuk untuk melompat keluar dari gelung, kita tidak boleh mengelakkan operasi penerimaan saluran yang berterusan.

3. Bagaimana untuk mengelakkan panik akibat penutupan saluran?

Apabila menggunakan fungsi close() untuk menutup saluran, salah satu perkara yang lebih penting untuk diperhatikan ialah kita perlu memastikan saluran ditutup selepas semua operasi menghantar semua nilai ke saluran itu selesai, jika tidak saluran tidak akan diterima sepenuhnya sebelum Melakukan operasi penutupan boleh menyebabkan panik. Mari kita lihat bagaimana untuk mengelakkan perkara ini daripada berlaku.

1. Menggunakan saluran cache

Untuk beberapa pengiraan kompleks atau operasi pengesahan yang perlu dilakukan sebelum menghantar data, kami boleh menggunakan saluran cache untuk mengelakkan situasi panik . Pelaksanaan khusus adalah seperti berikut:

ch := make(chan bool, 1)
go func() {
    // 进行复杂计算或者校验操作
    // ...
    ch <- true
}()

select {
case <- done:
    // 结束操作
case <- ch:
    // 处理收到的数据
}
close(ch)

Dalam kod di atas, kami menggunakan saluran dengan penimbal 1. Saluran ini hanya menyimpan nilai Boolean Apabila kami menyelesaikan operasi kompleks selepas mencipta goroutine, kami menghantar nilai sebenar ke saluran untuk menunjukkan bahawa operasi telah selesai. Kemudian tunggu dalam pernyataan pilih untuk menghantar nilai ke saluran atau menerima nilai dari saluran lain. Akhir sekali, kami menutup saluran menggunakan fungsi close().

2. Menggunakan pernyataan pilih

Apabila menggunakan pernyataan pilih, kita boleh menggunakan cawangan lalai untuk mengendalikan senario sebelum saluran ditutup. Contoh kod adalah seperti berikut:

func handleCh(channel chan int) {
    for {
        select {
        case val, ok := <- channel:
            if !ok {
                fmt.Println("channel has closed")
                return
            }
            fmt.Println("recieve val:", val)
        default:
            fmt.Println("no value received")
        }
    }
}

func main() {
    ch := make(chan int)
    for i := 0; i < 5; i++ {
        go func(val int) {
            ch <- val
        }(i)
    }
    close(ch)
    handleCh(ch)
}

// 输出结果：
// recieve val: 0
// recieve val: 1
// recieve val: 2
// recieve val: 3
// recieve val: 4
// channel has closed

Dalam kod di atas, kami telah mencipta fungsi handleCh() untuk mengendalikan nilai yang diterima daripada saluran. Dalam fungsi ini, kami menggunakan pernyataan pilih untuk memproses data yang diterima daripada saluran dan mengendalikan senario apabila saluran tidak ditutup dalam cawangan lalai. Apabila kita menutup saluran dalam fungsi utama, fungsi handleCh() akan berakhir seperti biasa. Walau bagaimanapun, perlu diingatkan bahawa apabila menggunakan cawangan lalai, ia mesti diletakkan di hujung, jika tidak, ia akan menyebabkan ralat program.

4. Ringkasan

Melalui pengenalan di atas, kami memahami sebab dan kaedah penutupan saluran di Golang. Secara umumnya, kita perlu menutup saluran secara manual untuk mengelakkan masalah seperti kebocoran memori dan penyekatan. Apabila menutup saluran, kita perlu menggunakan fungsi close() atau pernyataan gelung julat untuk mengelakkan panik. Pada masa ini, dalam pembangunan sebenar, kita boleh menggunakan saluran cache atau memilih kenyataan untuk memproses adegan sebelum saluran ditutup, untuk mencapai tujuan mengoptimumkan kesan program.

Atas ialah kandungan terperinci Saluran Golang ditutup. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!