golang dekat chan

Dalam bahasa Go, saluran ialah konsep yang sangat penting. Saluran menyediakan cara untuk menghantar data dengan selamat antara Goroutine yang berbeza. Dengan menggunakan saluran, kami boleh menghalang berbilang Goroutine daripada mengakses ruang memori kongsi dengan selamat, dengan itu mengurangkan kebarangkalian keadaan perlumbaan dalam program.

Kami tahu bahawa apabila menggunakan saluran, pengirim perlu menulis data ke saluran, dan kemudian penerima membaca data daripada saluran tersebut. Walau bagaimanapun, selepas data dalam saluran telah diterima, bagaimana untuk memastikan saluran ditutup seperti biasa? Dalam artikel ini, kami akan membincangkan cara menutup saluran dan perkara yang perlu anda pertimbangkan semasa menutup saluran.

1. Mengapa anda perlu menutup saluran

Apabila menggunakan saluran, kami biasanya menggunakan gelung julat untuk mengulangi elemen dalam saluran. Sebagai contoh, berikut ialah contoh membaca data daripada saluran:

func readData(ch chan int) {
    for data := range ch {
        fmt.Println(data)
    }
}

Dalam kod di atas, kami telah menggunakan gelung julat untuk untuk mengulangi elemen dalam saluran. Tetapi bagaimana jika saluran tidak pernah mempunyai data untuk dibaca? Dalam kes ini, gelung untuk julat akan sentiasa menyekat menunggu ketibaan data, yang akan menghalang program daripada keluar secara normal.

Oleh itu, kita memerlukan cara untuk menutup saluran supaya program boleh keluar dengan anggun selepas membaca semua data. Di samping itu, menutup saluran juga boleh mengingatkan penerima bahawa saluran itu tidak mempunyai data yang tersedia, sekali gus mengelakkan situasi sekatan atau kebuntuan yang tidak perlu.

2. Cara menutup saluran

Dalam bahasa Go, anda boleh menggunakan fungsi tutup terbina dalam untuk menutup saluran. Tandatangan fungsi tutup adalah seperti berikut:

func close(ch chan<- Type)

Dalam tandatangan di atas, simbol

Berikut ialah contoh menutup saluran menggunakan fungsi tutup:

func main() {
    ch := make(chan int)
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)
    }()
    for data := range ch {
        fmt.Println(data)
    }
}

Dalam kod di atas, kami mula-mula mencipta saluran integer ch. Kemudian, kami menggunakan Goroutine untuk menghantar data secara berterusan ke saluran Selepas menghantar 10 nombor, kami memanggil fungsi tutup untuk menutup saluran.

Seterusnya, kami menggunakan gelung untuk julat untuk melelakan elemen dalam saluran dan mencetaknya. Selepas semua data dalam saluran telah dibaca, gelung untuk julat akan keluar secara automatik.

3. Tutup saluran tidak buffer dan saluran buffer

Dalam contoh di atas, kami menunjukkan cara menggunakan fungsi tutup untuk menutup saluran tidak buffer. Apabila menutup saluran yang tidak dibuffer, semua data mesti dibaca, jika tidak, penyekatan akan berlaku. Jika terdapat goroutine yang menyekat pada saluran sebelum ia ditutup, mereka akan mendapat isyarat saluran ditutup dan keluar.

Apabila kami menutup saluran buffer, mungkin terdapat beberapa data yang belum dibaca. Apabila menutup saluran penimbal, semua data dalam saluran akan dibaca dahulu, dan kemudian isyarat penutupan akan dihantar kepada semua Goroutine.

Kami boleh menunjukkan cara untuk mematikan saluran penimbal dengan mengubah suai contoh di atas:

func main() {
    ch := make(chan int, 10)
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch)
    }()
    for data := range ch {
        fmt.Println(data)
    }
}

Dalam kod di atas, kami mengisytiharkan saluran ch sebagai saluran penimbal dan menukar saluran penimbal kepada The panjang ditetapkan kepada 10. Kami menggunakan Goroutine untuk menghantar data secara berterusan ke saluran. Sama seperti menutup saluran yang tidak dibuffer, kami menggunakan fungsi tutup untuk menutup saluran selepas menghantar 10 nombor. Dalam Goroutine utama, kami menggunakan gelung untuk julat untuk melelaran melalui data dalam saluran dan mengeluarkannya.

Jika terdapat Goroutine yang menyekat pada saluran selepas saluran ditutup, mereka akan mendapat isyarat saluran ditutup dan oleh itu keluar. Di samping itu, jika terdapat data yang belum dibaca dalam saluran, data ini akan dibuang secara automatik selepas menutup saluran.

4. Tutup saluran dengan selamat

Apabila menutup saluran, kita perlu memberi perhatian kepada beberapa perkara untuk memastikan operasi normal program:

1 lakukan operasi baca dan tulis serentak Tutup saluran

Jika saluran yang sama dibaca dan ditulis dalam berbilang Goroutine pada masa yang sama, dan fungsi tutup dipanggil dalam salah satu Goroutine, ia mungkin menyebabkan pengecualian dalam bacaan dan tulis operasi Goroutine lain pada saluran.

Oleh itu, apabila menggunakan saluran, kita harus mencuba yang terbaik untuk mengelakkan membaca dan menulis saluran yang sama dalam berbilang Goroutine pada masa yang sama. Jika kita mesti membaca dan menulis ke saluran yang sama pada masa yang sama, kita harus menggunakan kunci atau primitif penyegerakan lain untuk memastikan keselamatan serentak.

2. Jangan tutup saluran berulang kali

Jika kita cuba menutup saluran yang sama beberapa kali, pengecualian panik akan berlaku. Oleh itu, sebelum menutup saluran, kita harus memastikan saluran itu belum ditutup.

Saluran yang diberikan boleh disemak menggunakan nilai ok-idit:

v, ok := <- ch
if ok {
    // ch 未关闭，执行读取操作
} else {
    // ch 已关闭，执行相应的操作
}

Jika saluran telah ditutup, nilai ok akan menjadi palsu. Kita boleh menggunakan cara ini untuk menyemak sama ada saluran ditutup sebelum membaca daripadanya.

3. Jangan tutup saluran dalam Goroutine yang menerima saluran

Biasanya, kita harus menggunakan fungsi tutup untuk menutup saluran dalam Goroutine yang menghantar data. Menutup saluran dalam Goroutine yang menerima data boleh menyebabkan masalah di atas, seperti operasi baca dan tulis yang tidak normal pada saluran oleh Goroutine lain.

Oleh itu, apabila menggunakan saluran, kita harus memastikan bahawa saluran digunakan dengan betul untuk mengelakkan masalah yang sama.

5. Ringkasan

Dalam artikel ini, kami membincangkan cara menutup saluran dan perkara yang perlu dipertimbangkan semasa menutup saluran. Saluran adalah primitif konkurensi yang sangat penting dalam bahasa Go Cara yang betul untuk menggunakan saluran dapat mengelakkan masalah seperti keadaan perlumbaan dan kebuntuan dalam program dengan berkesan.

Oleh itu, semasa menulis kod, kita harus memahami sepenuhnya prinsip dan penggunaan saluran, dan menggunakan saluran secara munasabah untuk mencapai operasi serentak. Apabila menutup saluran, kita perlu memberi perhatian kepada isu seperti operasi serentak saluran dalam berbilang Goroutine dan penutupan saluran berulang untuk memastikan operasi program yang betul.

Atas ialah kandungan terperinci golang dekat chan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!