【Go】P18 Go语言并发编程核心（二）：Goroutine 与 Channel 的协同艺术 - 详解

Go 的并发哲学：CSP

在讨论 channel 之前，理解 Go 的并发模型至关重要。Go 采用了 CSP（Communicating Sequential Processes，通信顺序进程） 模型。这一理念的核心正如 Go 的一句著名格言所说：

“Do not communicate by sharing memory. instead, share memory by communicating.”（不要通过共享内存来通信；相反，要通过通信来共享内存。）

传统的 线程（Thread） 并发模型依赖于 共享内存（如全局变量、对象实例等），并通过 “锁”（Mutexes, Semaphores） 等机制来保护这些内存，以避免竞态条件，但这种方式极易出错。而 Go 提倡使用 channel 作为 goroutine 之间的数据通道。数据通过 channel 被安全地传递，以“先进先出”的原则，从一个 goroutine 的“手中”交到另一个 goroutine，从而天然地避免了数据竞争问题。

核心组件一：Goroutine（协程）

在 Go 中，启动一个并发任务异常简单：

go funcName() // 'go' 关键词启动一个新的协程 goroutine

goroutine 是一种轻量级线程，也称为“协程”，由 Go 运行时（runtime）管理。你可以在一个程序中轻松创建成千上万个 goroutine，它们的创建和切换成本远低于操作系统线程。

核心组件二：Channel（管道）

channel 是 Go 语言级别提供的 goroutine 间 通信的“管道”。它是一种特殊的类型，允许一个 goroutine 向另一个 goroutine 发送特定类型的值。

你可以将 channel 想象成一个传送带或队列，它总是遵循**先入先出（FIFO）**的规则，保证了数据的收发顺序。

1. 声明与初始化

channel 是一种引用类型。声明一个 channel 变量的格式如下：

var 管道名 chan 元素类型
// 示例
var ch1 chan int   // 声明一个传递 int 类型的管道
var ch2 chan bool  // 声明一个传递 bool 类型的管道

和 map、slice 一样，声明后的 channel 只是一个 nil 值，必须使用 make 函数进行初始化后才能使用：

ch := make(chan 元素类型, 容量)

channel 的初始化涉及一个非常重要的概念：容量（Capacity）。读者必须合理评估管道的最大即时并行容量，并将其作为容量的值。

无缓冲管道 (Unbuffered Channel)
当容量为 0（或省略）时，创建的是无缓冲管道。
```
ch := make(chan int) // 容量为 0
```
无缓冲管道要求发送方和接收方必须同时准备好。
- 一个 goroutine 尝试发送（ch <- 10）时，它会阻塞，直到有另一个 goroutine准备好接收（<- ch）。
- 反之，一个 goroutine 尝试接收（x := <- ch）时，它也会阻塞，直到有另一个 goroutine准备好发送（ch <- ...）。

这种特性使其成为一种强大的同步工具，可以用来““等待””另一个 goroutine 完成某个操作。

有缓冲管道 (Buffered Channel)
当容量大于 0 时，创建的是有缓冲管道。
```
ch := make(chan int, 3) // 容量为 3
```
有缓冲管道内部有一个小队列（缓冲区）。
- 发送操作（ch <- 10）只在缓冲区已满时才会阻塞。
- 接收操作（x := <- ch）只在缓冲区为空时才会阻塞。

这允许 goroutine 之间进行一定程度的解耦，发送方不必等待接收方立即可用，只要缓冲区没满，就可以继续发送和执行后续任务。

2. 核心操作：发送、接收、关闭

channel 共有三种操作，都使用非常直观的 <- 符号。

ch := make(chan int, 3)
// 1. 发送 (Send): 将一个值发送到管道中
ch <- 10
ch <- 20
// 2. 接收 (Receive): 从管道中接收一个值
x := <- ch // x 的值将是 10 (FIFO)
y := <- ch // y 的值将是 20
// 我们可以查看管道的当前长度(已用)和总容量
fmt.Println(len(ch)) // 此时缓冲区为空，输出 0
fmt.Println(cap(ch)) // 容量为 3
// 3. 关闭 (Close): 通知接收方管道已关闭，不会再有新数据
close(ch)

管道的 **关闭（Close）**是一个非常重要的操作：

关闭后，不能再向 channel 发送数据（会导致 panic）。
关闭后，接收方仍可以从 channel 接收数据，直到缓冲区为空。
当缓冲区为空后，再从已关闭的 channel 接收数据，会立即返回该类型的零值（如 int 的 0，string 的 ""）。

3. 遍历 Channel：for range

Go 提供了 for range 循环来优雅地从 channel 中持续接收数据，直到它被关闭。

func main() {
ch := make(chan int, 3)
// 启动一个 goroutine 发送数据
go func() {
ch <- 1
ch <- 2
ch <- 3
// 重点：数据发送完毕后，必须关闭管道
close(ch)
}()
// for range 会自动监听管道
// 当管道被关闭且缓冲区为空时，循环会自动结束
for v := range ch {
fmt.Println(v)
}
fmt.Println("管道已关闭，循环结束。")
}

注意： 如果你使用 for range 遍历一个 channel，但忘记在所有数据发送完毕后 close(ch)，那么 for range 循环将在接收完所有数据后永久阻塞，等待永远不会到来的新数据，整个程序会因为主 goroutine 无法退出而“卡死”，最终导致死锁（deadlock），并抛出著名的 fatal error: all goroutines are asleep - deadlock! 错误，然后终止程序。

实战：Goroutine 结合 Channel

结合使用 goroutine 和 channel，发挥最大的威力。

简单示例：生产者与消费者

我们创建两个 goroutine：一个负责 生产（写入）数据，另一个负责 消费（读取）数据。

import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup // 声明一个 WaitGroup
// 生产者
func producer(ch chan int) {
// 在函数结束时，调用 Done 来通知 WaitGroup 这个 goroutine 已经完成
defer wg.Done()
for i := 0; i < 5; i++ {
fmt.Println("生产者：发送", i)
ch <- i
time.Sleep(100 * time.Millisecond) // 模拟生产耗时
}
close(ch) // 生产结束，关闭管道
}
// 消费者
func consumer(ch chan int) {
// 在函数结束时，调用 Done 来通知 WaitGroup 这个 goroutine 已经完成
defer wg.Done()
// 使用 for range 消费
for v := range ch {
fmt.Println("---消费者：接收到", v)
time.Sleep(200 * time.Millisecond) // 模拟消费耗时
}
fmt.Println("---消费者：管道关闭，退出。")
}
func main() {
ch := make(chan int, 3) // 使用一个小型缓冲
// 告诉 WaitGroup 我们需要等待 2 个 goroutine (1个生产者, 1个消费者)
wg.Add(2)
go producer(ch) // 启动生产者
go consumer(ch) // 启动消费者
// 阻塞主 goroutine，直到 WaitGroup 的计数器归零
// 即，直到所有调用了 Add(1) 的 goroutine 都调用了 Done()
wg.Wait()
fmt.Println("主程序：所有 goroutine 已完成，程序退出。")
}

在这个例子中，即使 消费者（读取） 比 生产者（写入） 慢，channel 也会自动处理同步：

生产者快速填满缓冲区（3个）。
当缓冲区满时，生产者在 ch <- i 处阻塞。
消费者取出数据，缓冲区出现空位。
生产者解除阻塞，继续发送下一个数据。

高级示例：并发素数筛

这是一个更复杂的例子，它启动了多个 goroutine（一个“工人池”）来并发地计算素数，并使用 channel 来分配任务和收集结果。这个程序的目标是：计算 2 到 120000 之间的所有素数。

1. 组件分析

我们将需要三个管道 Channel：

intChan： 一个 channel，用于存放 2-120000 的所有数字（任务）。
primeChan： 一个 channel，用于存放计算后得到的素数（结果）。
exitChan： 一个 channel，用于标记计算素数的“工人” goroutine是否已完成工作。

2. 代码实现与解析

package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
// 1. putNum: 往 intChan 里存放数据
// 这是一个生产者
func putNum(intChan chan int) {
defer wg.Done()
for i := 2; i < 120000; i++ {
intChan <- i
}
close(intChan) // 数字放完了，关闭任务管道
}
// 2. primeNum: 从 intChan 取数，并判断是否为素数
// 这是一个消费者（消费任务）/ 生产者（生产结果）
// 我们会启动多个这样的 "工人"
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
defer wg.Done()
// 使用 for range 循环，intChan 关闭后自动退出
for num := range intChan {
var flag = true
// 判断是否为素数（这里为了演示，使用朴素算法）
for i := 2; i < num; i++ {
if num%i == 0 {
flag = false
break
}
}
if flag {
primeChan <- num // 是素数，放入结果管道
}
}
// 工作完成了，给 exitChan 发送一个信号
exitChan <- true
}
// 3. printPrime: 打印素数
// 这是一个消费者（消费结果）
func printPrime(primeChan chan int) {
defer wg.Done()
// 使用 for range 循环，primeChan 关闭后自动退出
for v := range primeChan {
fmt.Println(v, "是素数")
}
fmt.Println("结果管道已关闭")
}
func main() {
// 初始化管道
intChan := make(chan int, 1000)    // 任务管道
primeChan := make(chan int, 1000) // 结果管道
workerCount := 16                 // 启动 16 个 "工人"
exitChan := make(chan bool, workerCount) // 退出信号管道
// ------ 启动协程 ------
// 1. 启动存放数字的协程 (1个)
wg.Add(1)
go putNum(intChan)
// 2. 启动统计素数的协程 (16个)
for i := 0; i < workerCount; i++ {
wg.Add(1)
go primeNum(intChan, primeChan, exitChan)
}
// 3. 启动打印素数的协程 (1个)
wg.Add(1)
go printPrime(primeChan)
// 4. 启动一个 "协调者" 协程
//    这个协程的任务是：等待所有 "工人" (primeNum) 退出
//    当所有工人都退出后，它负责关闭 "结果管道" (primeChan)
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < workerCount; i++ {
<-exitChan // 等待一个工人的退出信号，会阻塞，直到收到
}
// 当 16 个信号都收到后，说明所有工人都干完活了
// 此时可以安全地关闭 primeChan
close(primeChan)
}()
// ------ 等待所有协程结束 ------
wg.Wait()
fmt.Println("所有协程执行完毕")
// 注意：关闭 exitChan 不是必须的，因为它只用于发送信号，
// 并且我们明确知道会接收 workerCount 次
close(exitChan)
}

3. 协调的关键

这个例子中最精妙的设计在于 exitChan 和那个匿名的“协调者” goroutine。

为什么需要 exitChan？printPrime 协程使用 for range 来遍历 primeChan。它必须在 primeChan 被 close() 后才能停止。
谁来关闭 primeChan？ 有 16 个 primeNum 协程在向 primeChan 写数据。我们必须确保在所有 primeNum 协程都执行完毕（即 intChan 被耗尽）之后，才能关闭 primeChan。
“协调者”的工作： 它通过 <-exitChan阻塞，等待 16 次。每当一个 primeNum 协程结束，它就向 exitChan 发送一个 true。当协调者收集齐 16 个 true 后，它就 100% 确定所有素数都已写入 primeChan，此时它就可以安全地 close(primeChan)，从而通知 printPrime 协程结束工作。

总结

goroutine 提供了并发执行的能力（“做什么”），而 channel 提供了它们之间安全、高效的通信与同步机制（“如何协作”）。

通过 channel，我们可以构建出清晰、健壮且高性能的并发程序，将复杂的多线程同步问题，简化为对数据流（管道）的管理。这正是 Go 语言并发模型的魅力所在。

2025.11.04 金融街

posted @ 2025-12-03 18:29 gccbuaa 阅读(10) 评论(0) 收藏举报

刷新页面返回顶部

gccbuaa