penggunaan golang chan

Golang ialah bahasa ditaip kuat yang terkenal dengan konkurensi tinggi dan sintaksnya yang ringkas. Antaranya, chan adalah salah satu kaedah komunikasi yang biasa di Golang dan bahagian penting dalam melaksanakan pengaturcaraan serentak. Dalam artikel ini, kita akan melihat secara mendalam tentang penggunaan dan asas chan di Golang.

1. Konsep dan peranan chan

Chan ialah cara penting untuk mencapai komunikasi antara goroutine di Golang, yang disebut sebagai saluran paip. Ia ialah struktur data selamat benang yang digunakan untuk menghantar maklumat dalam program Golang. chan boleh melaksanakan komunikasi sehala dan komunikasi dua hala, boleh digunakan untuk menghantar dan menerima data, dan juga boleh digunakan untuk menyegerakkan goroutine.

2. Jenis dan penggunaan chan

Chan dalam Golang ialah jenis yang boleh dibuat menggunakan fungsi make. Sintaks adalah seperti berikut:

ch := make(chan int)

di mana int mewakili jenis data yang dihantar dalam saluran paip. Anda perlu memberi perhatian kepada perkara berikut apabila menggunakan chan:

1. chan sedang menyekat

Kedua-dua operasi hantar dan terima menyekat, iaitu jika tiada padanan daripada operasi hantar dan terima , maka goroutine akan sentiasa disekat pada operasi ini. Contohnya:

ch := make(chan int)

// 发送操作
go func() {
   ch <- 1
}()

// 接收操作
a := <- ch

Dalam contoh ini, kami mencipta paip jenis int dan melaksanakan operasi penghantaran dan penerimaan masing-masing. Dalam operasi hantar, kami menghantar nilai 1 ke paip; dalam operasi terima, kami mengambil nilai dari paip dan menetapkannya kepada pembolehubah a. Memandangkan kedua-dua operasi hantar dan terima disekat, program ini akan menunggu sehingga operasi hantar dan terima sepadan sebelum ia boleh tamat seperti biasa.

2. Tutup chan

Anda boleh menggunakan fungsi tutup untuk menutup paip tidak boleh dihantar semula. Contohnya:

ch := make(chan int)

// 发送操作
go func() {
   ch <- 1
   close(ch)
}()

// 循环接收操作
for {
   if val, ok := <-ch; ok {
      fmt.Println(val)
   } else {
      break
   }
}

Dalam contoh ini, kami memanggil fungsi tutup selepas operasi hantar, dan kemudian gunakan gelung for untuk menerima saluran paip. Dalam operasi penerimaan, ok digunakan untuk menentukan sama ada saluran paip telah ditutup untuk mengelakkan kebuntuan.

3. Chan sehala

Chan sehala boleh dibuat dengan menetapkan arah paip. Contohnya:

ch := make(chan int) // 双向chan

// 定义只能发送的单向chan
sendCh := make(chan <- int)

// 定义只能接收的单向chan
recvCh := make(<- chan int)

// 发送操作时可以使用单向chan
go func() {
   sendCh <- 1
}()

// 接收操作时也可以使用单向chan
a := <-recvCh

Dalam contoh ini, kami mencipta chan dua hala melalui fungsi make, dan kemudian mencipta chan sehala yang hanya boleh menghantar dan hanya menerima melalui fungsi make. Dalam operasi penghantaran dan operasi penerimaan, kami menggunakan sendCh dan recvCh masing-masing.

4. penyataan pilih

Pernyataan pilih boleh memantau status berbilang saluran paip pada masa yang sama dan boleh digunakan untuk operasi baca dan tulis serentak saluran paip. Contohnya:

ch1 := make(chan int)
ch2 := make(chan int)

// 发送操作
go func() {
   ch1 <- 1
}()

// 使用select语句并发监听多个管道
select {
case a := <- ch1:
   fmt.Println(a)
case b := <- ch2:
   fmt.Println(b)
}

Dalam contoh ini, kami mencipta dua saluran paip ch1 dan ch2 dan menghantar nilai 1 ke ch1 dalam goroutine. Selepas itu, kami menggunakan pernyataan pilih untuk mendengar dua paip, dan pernyataan kes yang menerima nilai pertama telah dilaksanakan terlebih dahulu.

3. Prinsip asas chan

Di Golang, chan dilaksanakan berdasarkan struktur data khas. Apabila kita menggunakan fungsi make untuk mencipta chan, kita sebenarnya mencipta kepingan dengan nilai nol dan panjang 0, dipanggil saluran.

Kita boleh memahami prinsip chan dengan cara berikut:

1. Kendalian hantar

Apabila melakukan operasi hantar, data yang akan dihantar akan dilampirkan pada kepingan di bahagian bawah saluran. Jika panjang saluran ialah 0, maka indeks unsur tambahan ialah 0. Jika panjang saluran bukan 0, indeks elemen tambahan ialah panjang saluran.

Jika panjang saluran telah mencapai had kapasiti atasnya, kepingan yang lebih besar akan dibuat dalam memori dan elemen dalam kepingan asal akan disalin ke kepingan baharu. Oleh itu, apabila melakukan operasi penghantaran, pengurusan memori dan mekanisme penyalinan akan digunakan.

2. Kendalian penerimaan

Apabila melakukan operasi penerimaan, elemen pertama yang dilampirkan akan dikeluarkan daripada kepingan di bahagian bawah saluran. Jika tiada unsur dalam kepingan, ia akan menunggu sehingga elemen tersedia jika saluran telah ditutup, operasi penerimaan akan segera mengembalikan nilai sifar.

3. Menyekat

Apabila melakukan operasi hantar atau terima, jika panjang kepingan saluran telah mencapai had kapasiti atasnya, atau terdapat data dalam saluran menunggu untuk diterima, kemudian hantar Atau operasi terima akan menyekat sehingga ruang atau data yang mencukupi tersedia.

4. Tutup operasi

Apabila menutup saluran, status saluran akan ditetapkan kepada ditutup dan tiada lagi data boleh dihantar. Jika terdapat data yang tidak diterima dalam saluran, operasi penerimaan boleh diteruskan sehingga tiada data dalam saluran.

Ringkasan

Chan di Golang ialah cara penting untuk mencapai komunikasi antara goroutine, dan ia juga sangat ringkas dari segi sintaks. Menguasai penggunaan asas dan prinsip chan adalah sangat penting untuk pengaturcaraan serentak.

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