Saluran Tanpa Penimbal
Penyerahan segerak antara goroutine
Saluran Tanpa Penimbal ialah pelajaran Go Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Go Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Go Academy merangkumi sejumlah 4 pelajaran.
Apakah Saluran?
saluran ialah saluran berjenis untuk berkomunikasi antara goroutine. Saluran mengikut prinsip Go: Jangan berkomunikasi dengan berkongsi memori; kongsi memori dengan berkomunikasi.
package main
import "fmt"
func main() {
ch := make(chan int) // unbuffered int channel
go func() {
ch <- 42 // send: blocks until someone receives
}()
v := <-ch // receive: blocks until someone sends
fmt.Println(v) // 42
}Semantik Saluran Tanpa Penimbal
Saluran tanpa penimbal tidak mempunyai kapasiti. Penghantaran tersekat sehingga penerima bersedia, dan penerimaan tersekat sehingga penghantar menghantar. Ini menyediakan serahan segerak yang terjamin:
package main
import "fmt"
func double(in <-chan int, out chan<- int) {
for v := range in {
out <- v * 2
}
close(out)
}
func main() {
in := make(chan int)
out := make(chan int)
go double(in, out)
go func() { in <- 3; in <- 5; close(in) }()
for v := range out { fmt.Println(v) }
// 6
// 10
}Saluran sebagai Penyegerakan
Saluran tanpa penimbal menyegerakkan goroutine — gunakannya sebagai isyarat bahawa kerja telah selesai:
package main
import "fmt"
func compute(result chan<- int) {
sum := 0
for i := 1; i <= 100; i++ { sum += i }
result <- sum
}
func main() {
ch := make(chan int)
go compute(ch)
fmt.Println("Result:", <-ch) // blocks until compute sends
}Menutup Saluran
Penghantar menutup saluran dengan close(ch) untuk menandakan bahawa tiada nilai lagi akan dihantar. Penerima mengesan penutupan melalui bentuk dua nilai:
package main
import "fmt"
func generate(ch chan<- int, max int) {
for i := 0; i < max; i++ {
ch <- i
}
close(ch) // signal done
}
func main() {
ch := make(chan int)
go generate(ch, 5)
for v := range ch { // range detects close automatically
fmt.Println(v)
}
fmt.Println("channel closed")
}Penerimaan Dua Nilai
Penerimaan dua nilai v, ok := <-ch memberitahu anda sama ada saluran masih terbuka:
package main
import "fmt"
func main() {
ch := make(chan string, 1)
ch <- "hello"
close(ch)
v1, ok1 := <-ch
fmt.Println(v1, ok1) // hello true
v2, ok2 := <-ch
fmt.Println(v2, ok2) // "" false — channel closed
}Penghantaran pada Saluran Ditutup Menyebabkan Panik
Menghantar ke saluran yang ditutup menyebabkan panik. Hanya penghantar patut menutup saluran — jangan sekali-kali penerima:
package main
import "fmt"
func main() {
ch := make(chan int)
close(ch)
// Receiving from closed channel returns zero value
v, ok := <-ch
fmt.Println(v, ok) // 0 false
// Sending to closed channel panics:
defer func() { recover() }()
ch <- 1 // panic: send on closed channel
}Saluran Berarah
Hadkan saluran kepada penghantaran sahaja (chan<- T) atau penerimaan sahaja (<-chan T) dalam tandatangan fungsi demi kejelasan dan keselamatan:
package main
import "fmt"
func producer(out chan<- int) { // send-only
for i := 0; i < 3; i++ { out <- i }
close(out)
}
func consumer(in <-chan int) { // receive-only
for v := range in { fmt.Println(v) }
}
func main() {
ch := make(chan int)
go producer(ch)
consumer(ch)
}Ulang-alik Goroutine-Saluran
Dua goroutine menghantar mesej berulang-alik melalui saluran — demonstrasi penyegerakan klasik:
package main
import "fmt"
func ping(ping, pong chan struct{}) {
for i := 0; i < 3; i++ {
<-ping
fmt.Println("ping")
pong <- struct{}{}
}
}
func main() {
ping := make(chan struct{})
pong := make(chan struct{})
go func() { for { <-pong; fmt.Println("pong"); ping <- struct{}{} } }()
go func() { for i := 0; i < 3; i++ { ping <- struct{}{}; <-pong } }()
// Simplified version:
fmt.Println("channels enable structured communication")
}Saluran nil Menyekat Selama-lamanya
Menerima daripada atau menghantar kepada saluran nil akan tersekat selama-lamanya. Teknik ini kadangkala digunakan dengan sengaja dalam pernyataan select:
package main
import "fmt"
func main() {
var ch chan int // nil channel
fmt.Println(ch == nil) // true
// select with nil channel — that case is never selected
active := make(chan int, 1)
active <- 42
select {
case v := <-ch: // never selected (nil)
fmt.Println(v)
case v := <-active: // selected
fmt.Println("got:", v)
}
}Bila Hendak Menggunakan Saluran Tanpa Penimbal
Gunakan saluran tanpa penimbal apabila:
- Anda memerlukan serahan segerak yang terjamin
- goroutine mesti mengakui penerimaan sebelum penghantar meneruskan
- Melaksanakan semafor atau tekanan balik
- Membina saluran paip yang setiap peringkatnya perlu memproses satu item pada satu masa
Semakan Pantas
Apakah yang berlaku apabila anda menghantar pada saluran tanpa penimbal yang tiada penerima bersedia?
Ulang kaji: Saluran Tanpa Penimbal
Ringkasan:
- Cipta dengan
make(chan T)— kapasiti sifar - Penghantaran tersekat sehingga penerima bersedia; penerimaan tersekat sehingga penghantar menghantar
- Hanya penghantar patut menutup saluran
range chmengulangi proses sehingga saluran ditutup- Penerimaan dua nilai:
v, ok := <-ch - Gunakan jenis berarah demi kejelasan:
chan<-dan<-chan
Pelajari Go dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 51
- Pelajaran
- 203
Soalan Lazim
Adakah pelajaran “Saluran Tanpa Penimbal” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Go Academy, termasuk “Saluran Tanpa Penimbal”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Go Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Saluran Tanpa Penimbal”?
Penyerahan segerak antara goroutine Anda berlatih Go Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Go Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Go Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.
Berapa lamakah pelajaran “Saluran Tanpa Penimbal” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Go Academy ini?
Ya. Setiap pelajaran Go Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Melancarkan Goroutine
- Saluran Tanpa Penimbal
- Saluran Berpenimbal
- Arah Saluran dan Corak Pipeline