Kaedah pemprosesan tak segerak bagi pengaturcaraan serentak Select Channels Go menggunakan golang

Kaedah pemprosesan tak segerak bagi Select Channels Go pengaturcaraan serentak menggunakan golang

Pengenalan:
Pengaturcaraan serentak ialah pembangunan perisian moden di mana ia boleh meningkatkan prestasi dan responsif aplikasi anda dengan berkesan. Dalam bahasa Go, pengaturcaraan serentak boleh dilaksanakan dengan mudah dan cekap menggunakan penyataan Saluran dan Pilih. Artikel ini akan memperkenalkan cara menggunakan golang untuk melaksanakan pemprosesan tak segerak bagi pengaturcaraan serentak Select Channels Go dan memberikan contoh kod khusus.

1 Memahami Saluran dan Memilih penyataan
Saluran adalah saluran untuk komunikasi antara goroutin boleh merealisasikan pemindahan data antara gorouti yang berbeza. Dalam golang, saluran boleh dibuat dengan menggunakan kata kunci make, seperti yang ditunjukkan dalam kod berikut:

ch := make(chan int)

Gunakan nilai ch <- untuk menghantar data ke saluran, <- ch untuk menerima data daripada saluran. Dengan cara ini, kita boleh bertukar-tukar data dalam goroutine yang berbeza. Pernyataan Pilih digunakan untuk memantau operasi berbilang saluran pada masa yang sama Apabila salah satu saluran sedia, pernyataan Pilih akan melaksanakan operasi yang sepadan.

2. Gunakan penyataan Pilih untuk pemprosesan tak segerak
Dalam pengaturcaraan serentak, selalunya perlu memproses berbilang tugasan yang berbeza pada masa yang sama dan bukannya memprosesnya satu demi satu mengikut tertib. Pada masa ini, anda boleh menggunakan pernyataan Pilih untuk melaksanakan pemprosesan tak segerak, seperti yang ditunjukkan dalam kod berikut:

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        time.Sleep(time.Second)
        ch1 <- 1
    }()

    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- 2
    }()

    select {
    case <-ch1:
        fmt.Println("Received from ch1")
    case <-ch2:
        fmt.Println("Received from ch2")
    }
}

Dalam kod di atas, kami mencipta dua saluran ch1 dan ch2, dan menghantarnya ke dua goroutine masing-masing. Ia menghantar data. Gunakan pernyataan Pilih untuk mendengar kedua-dua saluran ini dan lakukan operasi yang sepadan apabila salah satu saluran sedia. Dalam kod, ch1 pertama menghantar data ke saluran Selepas satu saat, ch1 sudah sedia menjalankan operasi yang sepadan dan mencetak "Diterima daripada ch1" jika masa Tidur ch1 dan ch2 ditukar dicetak dahulu. "Diterima daripada ch2".

3 Ciri-ciri pernyataan Pilih

1. Jika berbilang saluran sudah sedia, pernyataan Pilih akan memilih salah satu daripadanya secara rawak untuk dilaksanakan.
2. Gunakan klausa lalai untuk melaksanakan beberapa operasi lalai apabila semua saluran tidak bersedia.
3. Penyataan pilihan boleh disarangkan untuk gelung untuk mencapai pelbagai pemantauan dengan menetapkan syarat keluar.

4 Gunakan pernyataan Pilih untuk menyelesaikan masalah tamat masa
Dalam aplikasi praktikal, selalunya perlu menetapkan tamat masa apabila tiada data daripada saluran diterima dalam masa yang ditetapkan, teruskan Mengendalikan sewajarnya. Fungsi ini boleh dicapai dengan menggabungkan pemasa dan pernyataan Pilih, seperti yang ditunjukkan dalam kod berikut:

func main() {
    ch := make(chan int)
    timeout := time.After(2 * time.Second)

    go func() {
        time.Sleep(3 * time.Second)
        ch <- 1
    }()

    select {
    case <-ch:
        fmt.Println("Received from ch")
    case <-timeout:
        fmt.Println("Timeout")
    }
}

Dalam kod di atas, kami membuat tamat masa dan menggunakan pernyataan pilih untuk mendengar ch dan acara tamat masa. Dalam goroutine, data dihantar ke ch selepas 3 saat simulasi melalui fungsi Tidur, dan masa tamat masa ditetapkan kepada 2 saat. Oleh itu, selepas 2 saat, pemasa tamat masa akan sedia, dan pernyataan pilih akan melaksanakan pemprosesan tamat masa dan mencetak "Tamat masa".

Kesimpulan:
Melalui penyataan Saluran dan Pilih, kami boleh melaksanakan pemprosesan tak segerak dan pengaturcaraan serentak dengan mudah dan cekap. Dengan menggunakan penyataan goroutine, saluran dan Pilih secara rasional, prestasi dan responsif program boleh dipertingkatkan. Saya harap artikel ini akan membantu dalam memahami kaedah pemprosesan tak segerak menggunakan pengaturcaraan serentak Select Channels Go dalam golang.

Rujukan:
https://golang.org/doc/effective_go.html#concurrency
https://go.dev/play/p/t4VZEnhoyC4#🎜🎜 #

Atas ialah kandungan terperinci Kaedah pemprosesan tak segerak bagi pengaturcaraan serentak Select Channels Go menggunakan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!