Bagaimanakah Penyata `select` Go Mengendalikan Keutamaan Saluran, dan Apakah Pendekatan Paling Cekap?

Keutamaan dalam Penyata Go Select: Pemahaman yang Disemak

Dalam Go, penyataan pilih ialah alat serba boleh untuk mengendalikan berbilang saluran secara serentak. Walau bagaimanapun, secara lalai, ia beroperasi tanpa sebarang pesanan keutamaan, yang berpotensi membawa kepada hasil yang tidak dijangka. Artikel ini mengkaji senario penyelesaian biasa dan memberikan pemahaman yang lebih bernuansa tentang pengendalian keutamaan dalam Go.

Pertimbangkan coretan kod berikut:

func sender(out chan int, exit chan bool) {
    for i := 1; i <= 10; i++ {
        out <- i
    } 
    exit <- true
}

func main(){
    out := make(chan int, 10)
    exit := make(chan bool)

    go sender(out, exit)

    L:
    for {
        select {
            case i := <-out:
                fmt.Printf("Value: %d\n", i)
            case <-exit:
                fmt.Println("Exiting")
                break L
        }
    }
    fmt.Println("Did we get all 10? Most likely not")
}

Dalam contoh ini, kami ingin menerima nilai daripada kedua-dua saluran keluar dan keluar dan mengendalikannya dalam susunan tertentu. Walau bagaimanapun, penyataan pilih membenarkan kedua-dua saluran dikendalikan secara serentak, membolehkan anda menerima isyarat keluar sebelum semua nilai dari keluar diterima.

Untuk menangani isu ini, penyelesaian yang biasa dicadangkan ialah menggunakan kes lalai untuk saluran yang tidak dikendalikan. Walau bagaimanapun, kenyataan pilihan Go menyokong pengendalian keutamaan secara asli, menghapuskan keperluan untuk penyelesaian.

Penyelesaian Asli

Kuncinya terletak pada mengasingkan saluran keluar kepada pengeluar. Apabila pengeluar ingin memberi isyarat penamatan, ia menutup saluran keluar. Akibatnya, hanya apabila saluran keluar kosong dan ditutup, pengguna akan menerima isyarat keluar. Ini dicapai dengan mengedarkan saluran keluar:

func main() {
    vals, quit := make(chan int, 10), make(chan bool)
    go produceEndlessly(vals, quit)
    go quitRandomly(quit)
    for x := range vals {
        fmt.Println(x)
        processed++
        time.Sleep(time.Duration(rand.Int63n(5e8)))
    }
    fmt.Println("Produced:", produced)
    fmt.Println("Processed:", processed)
}

Dalam contoh yang diubah suai ini, fungsi produceEndlessly secara berterusan menolak nilai ke dalam saluran vals sehingga ia menerima isyarat untuk berhenti. Fungsi quitRandomly menghantar isyarat selepas kelewatan rawak.

Dengan menjangkau saluran vals, pengguna menunggu sehingga semua nilai telah diterima dan saluran ditutup sebelum meneruskan untuk mengendalikan isyarat keluar. Ini memastikan bahawa semua nilai daripada saluran vals diproses sebelum program keluar.

Kesimpulan

Penyataan pilih Go menyediakan penyelesaian yang mantap untuk mengendalikan berbilang saluran secara serentak. Dengan memahami keupayaan pengendalian keutamaan asli Go, adalah mungkin untuk melaksanakan mekanisme pemilihan berasaskan keutamaan tanpa memerlukan penyelesaian. Pendekatan ini memudahkan kod dan meningkatkan kejelasan dan kecekapan pengendalian saluran dalam program Go.

Atas ialah kandungan terperinci Bagaimanakah Penyata `select` Go Mengendalikan Keutamaan Saluran, dan Apakah Pendekatan Paling Cekap?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!