Perbincangan mendalam tentang penggunaan penyataan pilih di Golang

Di Golang, pernyataan pilih ialah struktur kawalan berguna yang membolehkan anda memilih antara berbilang saluran untuk mendapatkan nilai yang sedia untuk dibaca atau ditulis tanpa menyekat operasi lain.

Dalam artikel ini, kita akan menyelidiki penggunaan pernyataan terpilih dalam Golang, sintaksnya dan peranannya dalam komunikasi berbilang saluran.

Pilih Asas Penyata

Di Golang, kami menggunakan penyata pilihan untuk membaca data daripada berbilang saluran. Saluran ini boleh terdiri daripada sebarang jenis seperti paip, saluran penampan, saluran tidak terpimpan, dsb. Berikut ialah contoh pilihan mudah:

package main

import "fmt"

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        for {
            c1 <- "from 1"
            time.Sleep(time.Second * 2)
        }
    }()

    go func() {
        for {
            c2 <- "from 2"
            time.Sleep(time.Second * 3)
        }
    }()

    go func() {
        for {
            select {
            case msg1 := <-c1:
                fmt.Println("Message 1", msg1)
            case msg2 := <-c2:
                fmt.Println("Message 2", msg2)
            }
        }
    }()

    var input string
    fmt.Scanln(&input)
}

Dalam contoh ini, kami telah mencipta dua saluran c1 dan c2. Kemudian kami menyediakan dua goroutine untuk menulis data ke saluran setiap 2 saat dan 3 saat masing-masing. Kami menggunakan pernyataan pilih untuk mendengar semua saluran dan mencetak sebarang mesej yang diterima daripada saluran.

Sintaks pernyataan pilih

Berikut ialah bentuk umum pernyataan pilih:

select {
case <-channel1:
    // do something with channel1
case <-channel2:
    // do something with channel2
default:
    // do something default
}

Pernyataan pilih termasuk beberapa pernyataan kes dan pernyataan lalai. Operasi saluran disertakan dalam setiap pernyataan kes, dan saluran ini boleh menjadi jenis saluran yang berbeza. Apabila pernyataan pilih dilaksanakan, ia menunggu untuk mana-mana satu daripada operasi saluran selesai. Jika berbilang operasi saluran sedia, pilih akan secara rawak memilih salah satu saluran, iaitu, secara rawak memilih saluran untuk dilaksanakan.

Jika tiada saluran yang disediakan atau pernyataan lalai, pernyataan lalai akan dilaksanakan. Jika tiada pernyataan lalai, pernyataan pilih akan disekat.

Senario penggunaan pernyataan pilih

Pernyataan pilih sangat berguna apabila berurusan dengan komunikasi berbilang saluran. Berikut ialah beberapa senario penggunaan biasa:

Senario 1: Pemprosesan Strim

Jika anda sedang memproses data penstriman, anda perlu menggunakan penyata terpilih untuk membaca data daripada berbilang saluran. Berikut ialah contoh mudah:

package main

import "fmt"

func main() {

    even := make(chan int)
    odd := make(chan int)
    quit := make(chan int)

    go send(even, odd, quit)
    receive(even, odd, quit)
}

func send(even, odd, quit chan<- int) {
    for i := 0; i <= 10; i++ {
        if i%2 == 0 {
            even <- i
        } else {
            odd <- i
        }
    }
    quit <- 0
}

func receive(even, odd, quit <-chan int) {
    for {
        select {
        case v := <-even:
            fmt.Println("Even number: ", v)
        case v := <-odd:
            fmt.Println("Odd number: ", v)
        case <-quit:
            return
        }
    }
}

Dalam contoh ini, kami mencipta tiga saluran: saluran genap, saluran ganjil dan saluran keluar. Dalam fungsi hantar, kami menghantar satu siri nombor. Dalam fungsi terima, kami menggunakan penyata pilih untuk membaca nombor daripada saluran genap dan ganjil dan keluar apabila saluran keluar sudah sedia.

Senario 2: Pengendalian Tamat Masa

Dalam sesetengah kes, anda mungkin perlu menambah syarat tamat masa pada pernyataan pilih jika operasi mengambil masa yang lama untuk diselesaikan. Berikut ialah contoh mudah:

package main

import (
    "fmt"
    "time"
)

func main() {

    c1 := make(chan string)

    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()

    select {
    case result := <-c1:
        fmt.Println(result)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }
}

Dalam contoh ini, kami mencipta saluran c1 dan melaksanakan operasi dengan kelewatan 2 saat dalam goroutine untuk mensimulasikan operasi yang berjalan lama. Kemudian kami cuba membaca hasilnya selepas menunggu masa yang diperlukan dalam pernyataan pilih. Memandangkan tamat masa adalah lebih pendek daripada masa operasi, operasi baca akan tamat masa dan mencetak mesej tamat masa dan bukannya nilai dalam saluran.

Nota tentang pernyataan pilihan

Apabila menggunakan pernyataan pilihan, anda mesti memberi perhatian kepada perkara berikut:

1. Penyata pilihan hanya boleh digunakan untuk operasi saluran. Jika anda perlu melakukan sebarang operasi lain, anda tidak boleh menggunakan pernyataan pilih.
2. Pernyataan kes dalam pernyataan pilih hendaklah merupakan operasi tanpa sekatan. Jika pernyataan kes anda mengandungi operasi menyekat, ia tidak akan dipilih.
3. Jika terdapat kekaburan dalam pernyataan kes dalam pernyataan pilih (contohnya, dua saluran sedia pada masa yang sama), saluran akan dipilih secara rawak.
4. Jika semua kes dalam pilihan adalah operasi tidak menyekat dan tiada pernyataan lalai, pernyataan pilih akan menyekat sehingga sekurang-kurangnya satu saluran sedia.

Kesimpulan

Dalam artikel ini, kami mempunyai pemahaman yang mendalam tentang senario penggunaan, sintaks dan penggunaan pernyataan pilih. Kami boleh mendapatkan semula data yang diperlukan daripada berbilang saluran, membolehkan komunikasi yang lebih cekap dan kawalan serentak. Sebagai pembangun Golang, anda mesti mahir dalam penyataan pilih supaya anda boleh menggunakannya secara fleksibel dalam amalan.

Atas ialah kandungan terperinci Perbincangan mendalam tentang penggunaan penyataan pilih di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!