在go语言中，当多个goroutine同时尝试从同一个channel接收数据时，其行为并非由语言规范明确定义，而是由go运行时调度器（scheduler）负责管理。这意味着消息的接收顺序和分配给哪个goroutine是非确定性的。调度器会决定哪个等待中的goroutine会接收到值。因此，开发者不应依赖于特定的接收顺序或消息分配模式。
最初的示例代码展示了这种非确定性：
c := make(chan string)
for i := 0; i < 5; i++ {
go func(i int) {
// 尝试从c接收值
<-c
// 接收后，向c发送一个新值
c <- fmt.Sprintf("goroutine %d", i)
}(i)
}
c <- "hi" // 主Goroutine向c发送一个值
fmt.Println(<-c) // 主Goroutine从c接收一个值在这个例子中，主Goroutine发送一个“hi”到Channel c。理论上，这会唤醒一个正在等待的子Goroutine。被唤醒的Goroutine接收到“hi”后，会立即向Channel c 发送一个包含其自身ID的新字符串。最终，主Goroutine接收到的将是某个子Goroutine发送的字符串。由于调度器的不确定性，这个“某个子Goroutine”可能是goroutine 0，也可能是goroutine 4，或者其他任何一个。
另一个更复杂的例子展示了消息在多个Goroutine之间传递：
c := make(chan string)
for i := 0; i < 5; i++ {
go func(i int) {
msg := <-c // 接收消息
c <- fmt.Sprintf("%s, hi from %d", msg, i) // 添加信息后重新发送
}(i)
}
c <- "original" // 初始消息
fmt.Println(<-c) // 最终消息在这个链式传递的例子中，消息从一个Goroutine传递到下一个，每个Goroutine都会在消息中添加自己的标识。最终，主Goroutine会收到一个包含了所有Goroutine信息的字符串。这同样依赖于调度器如何依次唤醒等待中的Goroutine，其具体顺序在不同运行环境下可能有所不同。
立即学习“go语言免费学习笔记（深入）”；
为了构建更可靠、更易于理解的并发程序，以下是一些推荐的最佳实践：
优先使用形式参数传递Channel： 将Channel作为函数参数传递给Goroutine，并尽可能使用单向Channel类型（chan<-用于发送，<-chan用于接收）。这样做有以下好处：
避免同一Goroutine内同时读写同一Channel： 尽量避免让同一个Goroutine既从一个Channel接收数据，又向同一个Channel发送数据（主Goroutine也应遵循此原则）。这种模式极易导致死锁，因为Goroutine可能会在等待自身发送或接收消息时被阻塞。将读写职责分离到不同的Goroutine或使用不同的Channel可以大大降低死锁的风险。
合理使用Channel缓冲： 将Channel缓冲视为一种性能优化手段，而非解决死锁的工具。通常，建议先从无缓冲Channel开始设计程序。如果程序在无缓冲模式下不会死锁，那么添加缓冲通常也不会导致死锁（但反之不成立，有缓冲的程序可能隐藏死锁）。只有当性能分析表明缓冲能够带来显著提升时，才考虑添加缓冲。
理解了上述最佳实践后，我们通过两个常见模式来演示Go Channel的强大功能。
此模式下，多个Goroutine向同一个Channel发送数据，而一个Goroutine（通常是主Goroutine）负责从该Channel接收所有数据。Go语言会自动交错这些消息，确保所有数据都能被接收。
package main
import (
"fmt"
"time"
)
func main() {
c := make(chan string) // 创建一个无缓冲Channel
// 启动5个Goroutine作为写入者
for i := 1; i <= 5; i++ {
go func(id int, co chan<- string) { // 使用单向发送Channel作为参数
for j := 1; j <= 5; j++ {
co <- fmt.Sprintf("hi from %d.%d", id, j) // 每个Goroutine发送5条消息
time.Sleep(time.Millisecond * 10) // 模拟一些工作，使并发更明显
}
}(i, c)
}
// 主Goroutine作为唯一的读取者，接收所有25条消息
for i := 1; i <= 25; i++ {
fmt.Println(<-c)
}
fmt.Println("所有消息接收完毕。")
}代码解析：
此模式下，一个Goroutine向Channel发送数据，而多个Goroutine同时从该Channel接收数据。Go调度器会负责将消息公平地（但非确定性地）分配给等待中的读取者。为了确保所有读取者都有机会完成工作，我们通常需要使用sync.WaitGroup来等待所有子Goroutine结束。
package main
import (
"fmt"
"sync"
"time"
)
func main() {
c := make(chan int) // 创建一个无缓冲Channel
var w sync.WaitGroup // 用于等待所有读取Goroutine完成
w.Add(5) // 设置WaitGroup计数器为5，对应5个读取Goroutine
// 启动5个Goroutine作为读取者
for i := 1; i <= 5; i++ {
go func(id int, ci <-chan int) { // 使用单向接收Channel作为参数
defer w.Done() // Goroutine结束时通知WaitGroup
j := 1
for v := range ci { // 循环从Channel接收数据，直到Channel关闭
time.Sleep(time.Millisecond * 50) // 模拟处理消息所需时间
fmt.Printf("Goroutine %d.%d 收到值: %d\n", id, j, v)
j += 1
}
fmt.Printf("Goroutine %d 完成接收。\n", id)
}(i, c)
}
// 主Goroutine作为唯一的写入者，发送25个整数
for i := 1; i <= 25; i++ {
c <- i
}
close(c) // 发送完毕后关闭Channel，通知读取者不再有数据
w.Wait() // 等待所有读取Goroutine完成
fmt.Println("所有Goroutine已完成，主程序退出。")
}代码解析：
Go语言的Channel是实现并发通信的强大原语。理解其调度器处理多Goroutine操作同一Channel的非确定性行为至关重要。通过遵循最佳实践，如使用形式参数、分离读写职责以及谨慎使用缓冲，开发者可以构建出更加健壮、可预测且易于维护的并发程序。无论是多写入者单读取者，还是单写入者多读取者模式，Go Channel都能提供灵活高效的解决方案。
以上就是Go语言中多Goroutine监听同一Channel的行为与最佳实践的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
648
收藏
