📚 课程目录第4章 Go并发编程基础

4. Go 并发编程基础：goroutine、channel、select、sync.WaitGroup、sync.Mutex

在微服务接口编排与限流熔断骨架中，高并发是常态。Go 语言通过轻量级 goroutine 和原生并发原语，让开发者能够以简洁、安全的方式编排大量异步任务。本章将系统讲解 Go 并发编程的五大核心构件，为后续实现令牌桶、滑动窗口、熔断状态机等骨架组件奠定基础。

4.1 goroutine：轻量级并发单元

goroutine 是 Go 运行时管理的用户态线程，初始栈仅 2KB，可动态伸缩。相比操作系统线程，goroutine 的创建和切换开销极低，单进程可轻松启动数十万个 goroutine。

  关键特性：
  使用 go 关键字启动，函数或闭包均可。
主 goroutine 退出时，所有子 goroutine 立即终止。
非抢占式协作调度，由 Go 运行时在 GC、系统调用、chan 操作等时机自动切换。

// 启动一个匿名 goroutine
go func() {
    fmt.Println("hello from goroutine")
}()

// 启动命名函数 goroutine
func worker(id int) {
    fmt.Printf("worker %d started\n", id)
}
go worker(1)

实践建议：在限流熔断骨架中，每个请求的令牌获取、滑动窗口计数、熔断状态判断都应封装为独立的 goroutine 任务，利用并发提升吞吐。

4.2 channel：goroutine 间通信

Go 设计哲学强调“不要通过共享内存来通信，而要通过通信来共享内存”。channel 是 goroutine 之间传递数据的管道，支持有缓冲和无缓冲两种模式。

类型	声明方式	行为特性	适用场景
无缓冲 channel	`make(chan T)`	发送和接收必须同时就绪，否则阻塞	同步信号、精确协调
有缓冲 channel	`make(chan T, N)`	缓冲区未满时发送不阻塞，未空时接收不阻塞	任务队列、流量削峰
单向 channel	`chan<- T` / `<-chan T`	限制发送或接收方向，增强类型安全	函数参数约束

// 无缓冲 channel：同步传递
ch := make(chan int)
go func() {
    ch <- 42  // 发送，阻塞直到接收
}()
val := <-ch  // 接收
fmt.Println(val) // 42

// 有缓冲 channel：异步队列
bufCh := make(chan string, 3)
bufCh <- "task1"
bufCh <- "task2"
bufCh <- "task3"
// bufCh <- "task4" // 缓冲区满，阻塞

// 单向 channel 约束
func producer(out chan<- int) {
    for i := 0; i < 5; i++ {
        out <- i
    }
    close(out)
}

常见陷阱：

向已关闭的 channel 发送数据会引发 panic。
从已关闭的 channel 接收数据会立即返回零值，需配合 ok 判断。
无缓冲 channel 容易导致死锁，务必确保发送和接收成对出现。

4.3 select：多路复用与超时控制

select 语句让一个 goroutine 同时等待多个 channel 操作，当任意一个 case 就绪时执行对应分支。这是实现超时、取消、多路任务编排的核心机制。

select {
case v <- ch1:
    fmt.Println("received from ch1:", v)
case v <- ch2:
    fmt.Println("received from ch2:", v)
case <-time.After(2 * time.Second):
    fmt.Println("timeout, no data received")
default:
    fmt.Println("no channel ready, non-blocking")
}

  限流骨架中的应用：在令牌桶实现中，select 用于同时等待令牌发放 channel 和超时 channel，实现带超时的令牌获取。

4.4 sync.WaitGroup：等待 goroutine 完成

sync.WaitGroup 用于等待一组 goroutine 全部执行完毕。它维护一个内部计数器，通过 Add、Done、Wait 三个方法控制。

方法	作用	典型调用位置
`Add(delta int)`	增加计数器	启动 goroutine 前
`Done()`	计数器减 1	goroutine 退出前
`Wait()`	阻塞直到计数器归零	主 goroutine 中

var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        fmt.Printf("worker %d done\n", id)
    }(i)
}
wg.Wait() // 等待所有 worker 完成
fmt.Println("all workers finished")

最佳实践：

Add 必须在启动 goroutine 之前调用，避免竞态。
使用 defer wg.Done() 确保即使 panic 也能正确减计数。
计数器不能为负，否则 panic。

4.5 sync.Mutex：保护共享资源

当多个 goroutine 并发读写同一变量时，需要使用互斥锁 sync.Mutex 保证数据一致性。Go 标准库提供 Mutex（互斥锁）和 RWMutex（读写锁）两种。

锁类型	方法	特性	适用场景
`sync.Mutex`	`Lock()` / `Unlock()`	同一时刻只允许一个 goroutine 访问	写多读少、简单互斥
`sync.RWMutex`	`RLock()` / `RUnlock()` + `Lock()` / `Unlock()`	读锁可共享，写锁独占	读多写少、配置读取

type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

锁使用原则：

锁的粒度要小，避免在锁内执行耗时操作（如 I/O、网络请求）。
始终使用 defer 释放锁，防止遗漏导致死锁。
优先使用 channel 传递数据，只在必要时使用 Mutex。
RWMutex 在写锁持有时会阻塞所有读锁，注意写锁饥饿问题。

4.6 并发原语在限流熔断骨架中的协作

在限流熔断骨架中，这些并发原语协同工作，构成高并发编排的基础设施：

goroutine：每个请求处理、令牌发放、滑动窗口计数都运行在独立 goroutine 中。
channel：令牌桶通过 buffered channel 实现令牌队列；熔断状态变更通过 channel 通知下游。
select：实现带超时的令牌获取、多路熔断信号监听。
WaitGroup：等待批量初始化完成、优雅关闭前等待所有处理 goroutine 退出。
Mutex：保护滑动窗口的计数数组、熔断器的状态字段等共享内存。

骨架代码片段示意：

// 令牌桶：buffered channel 作为令牌池
type TokenBucket struct {
    tokens chan struct{}
}

func NewTokenBucket(rate int) *TokenBucket {
    tb := &TokenBucket{
        tokens: make(chan struct{}, rate),
    }
    // 定时发放令牌的 goroutine
    go func() {
        ticker := time.NewTicker(time.Second / time.Duration(rate))
        for range ticker.C {
            select {
            case tb.tokens <- struct{}{}:
            default: // 桶满，丢弃
            }
        }
    }()
    return tb
}

// 带超时的令牌获取
func (tb *TokenBucket) Acquire(timeout time.Duration) bool {
    select {
    case <-tb.tokens:
        return true
    case <-time.After(timeout):
        return false
    }
}