Panduan praktikal untuk Select Channels Go pengaturcaraan serentak menggunakan golang

Panduan praktikal untuk menggunakan golang untuk Select Channels Go concurrent programming

Pengenalan:
Dalam aplikasi komputer moden, High concurrency ialah menjadi semakin penting. Untuk menggunakan sepenuhnya prestasi komputer, kita perlu menggunakan pengaturcaraan serentak untuk mencapai multitasking. Golang ialah bahasa pengaturcaraan berprestasi tinggi yang menyokong pengaturcaraan serentak Ia menyediakan mekanisme yang dipanggil "Saluran" untuk melaksanakan komunikasi serentak. Dengan menggunakan penyataan Saluran dan Pilih, kami boleh melaksanakan pengaturcaraan serentak dengan mudah. Artikel ini akan memperkenalkan anda kepada cara menggunakan penyataan Saluran dan Pilih dalam Golang untuk pengaturcaraan serentak dan memberikan contoh kod khusus.

1. Konsep asas Saluran
Di Golang, Saluran ialah mekanisme komunikasi yang digunakan untuk memindahkan data antara Goroutines (fungsi yang dilaksanakan secara serentak). Ia boleh dianggap sebagai paip antara Goroutine yang melaluinya data mengalir. Saluran mempunyai dua sifat penting: menyekat dan penyegerakan.

1. Menyekat: Apabila Goroutine menghantar data ke Saluran, jika Saluran penuh, operasi penghantaran akan disekat sehingga Saluran mempunyai kedudukan bebas semula. Begitu juga, jika Goroutine menerima data daripada Saluran, tetapi Saluran itu kosong, operasi terima akan disekat sehingga data tersedia dalam Saluran.
2. Penyegerakan: Saluran boleh digunakan untuk penyegerakan antara Goroutines. Apabila Goroutine menghantar data ke Saluran, ia menunggu Goroutine yang menerima menerima data sebelum meneruskan. Begitu juga, apabila Goroutine menerima data daripada Saluran, ia akan menunggu sehingga Goroutine menghantar selesai menghantar data sebelum meneruskan.

2 Gunakan pernyataan Pilih
Di Golang, pernyataan Pilih ialah mekanisme untuk mengendalikan berbilang operasi Saluran. Ia serupa dengan pernyataan suis, tetapi digunakan untuk mengendalikan operasi baca dan tulis pada Saluran.

1. Pilih sintaks pernyataan

   select {
   case channel1 <- data1:
    // 当 channel1 可用时执行
   case data2 := <-channel2:
    // 当 channel2 可用时执行
   case data3, ok := <-channel3:
    // 当 channel3 可用时执行
    // 如果 Channel 被关闭，ok 会被设置为 false，否则为 true
   default:
    // 如果没有任何 Channel 操作可用，则执行 default 语句块
   }

2. Pilih prinsip kerja pernyataan
#🎜 Bila semua saluran🎜 tersedia, Select akan secara rawak memilih Saluran yang tersedia untuk melaksanakan operasi yang berkaitan.
Jika tiada Saluran tersedia dan tiada blok pernyataan lalai, pernyataan Pilih akan disekat sehingga sekurang-kurangnya satu Saluran tersedia.
Jika berbilang Saluran tersedia dan tiada blok pernyataan lalai, pernyataan Pilih akan memilih Saluran yang tersedia secara rawak untuk melaksanakan operasi yang berkaitan. Oleh itu, jika berbilang Saluran tersedia, kami tidak dapat meramalkan Saluran mana yang akan dipilih.

3 Panduan Amalan

Berikut ialah beberapa garis panduan amalan untuk menggunakan Penyataan Saluran dan Pilih:

#🎜🎜 Saluran
1. Gunakan fungsi make terbina dalam untuk mencipta Saluran. Kod sampel adalah seperti berikut:

   ch := make(chan int)

   
   

Hantar dan terima data
2. Gunakan operator <- untuk menghantar dan menerima data ke Saluran. Kod sampel adalah seperti berikut:

   ch <- data // 发送数据
   data := <-ch // 接收数据

   
   

Gunakan pernyataan Pilih untuk operasi serentak
3. Gunakan pernyataan Pilih untuk mengendalikan berbilang operasi Saluran. Kod sampel adalah seperti berikut:

   select {
   case ch1 <- data1:
    // 当 ch1 可用时执行发送操作
   case data2 := <-ch2:
    // 当 ch2 可用时执行接收操作
   }

   
   

Tutup Saluran
4. Gunakan fungsi tutup terbina dalam untuk menutup Saluran. Kod sampel adalah seperti berikut:

   close(ch)

   
   

Simulasi tugas serentak
5. Goroutine dan Saluran boleh digunakan untuk mensimulasikan tugasan yang dilaksanakan serentak. Kod sampel adalah seperti berikut:

   func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("Worker", id, "started job", j)
        time.Sleep(time.Second)
        fmt.Println("Worker", id, "finished job", j)
        results <- j * 2
    }
   }
   
   func main() {
    // 创建输入和输出 Channels
    jobs := make(chan int, 100)
    results := make(chan int, 100)
   
    // 创建并发 Goroutines
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
   
    // 发送任务到输入 Channel
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)
   
    // 输出结果
    for a := 1; a <= 9; a++ {
        <-results
    }
   }

   
   
Artikel ini memperkenalkan cara menggunakan penyataan Saluran dan Pilih dalam Golang untuk pengaturcaraan serentak. Dengan menggunakan penyataan Saluran dan Pilih, kami boleh melaksanakan tugas serentak dengan mudah. Saya harap artikel ini dapat membantu anda lebih memahami mekanisme pengaturcaraan serentak Golang dan memberikan beberapa panduan berguna untuk projek anda.

Rujukan:

"Concurrency in Go", Blog The Go, [Dalam Talian]. is-not-parallelism.

1. "Effective Go", The Go Programming Language, [Dalam Talian]. 🎜#

Atas ialah kandungan terperinci Panduan praktikal untuk Select Channels Go pengaturcaraan serentak menggunakan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!