Go限流熔断接口编排与服务集成 - 第2节

2. Go 语言并发基础回顾：Goroutine 与 Channel 的基本用法

在构建高吞吐、低延迟的限流熔断骨架之前，必须牢固掌握 Go 语言的两大并发原语：Goroutine 与 Channel。它们是后续实现令牌桶、漏桶、滑动窗口等限流器的核心执行单元与通信媒介。

2.1 Goroutine：轻量级并发执行单元

Goroutine 是 Go 运行时管理的轻量级线程，创建成本极低（初始栈仅几 KB），可轻松启动数十万个并发任务。使用 go 关键字即可启动一个 Goroutine：

package main

import (
    "fmt"
    "time"
)

func worker(id int) {
    fmt.Printf("Worker %d 开始执行\n", id)
    time.Sleep(100 * time.Millisecond)
    fmt.Printf("Worker %d 执行完毕\n", id)
}

func main() {
    for i := 1; i <= 5; i++ {
        go worker(i) // 启动 5 个并发 Goroutine
    }
    // 等待所有 Goroutine 完成（后续用 WaitGroup 改进）
    time.Sleep(1 * time.Second)
    fmt.Println("主 Goroutine 退出")
}

2.2 Channel：Goroutine 之间的安全通信

Channel 是 Go 语言提供的类型安全、并发安全的通信管道。遵循“不要通过共享内存来通信，而应通过通信来共享内存”的设计哲学。

// 无缓冲 Channel 示例：Goroutine 间同步
func main() {
    ch := make(chan string)

    go func() {
        ch <- "限流器准备就绪"
    }()

    msg := <-ch
    fmt.Println(msg) // 输出：限流器准备就绪
}

// 有缓冲 Channel 示例：令牌桶模拟
func main() {
    tokens := make(chan struct{}, 10) // 最多 10 个令牌
    for i := 0; i < 10; i++ {
        tokens <- struct{}{}
    }
    // 消费一个令牌
    <-tokens
    fmt.Println("获取令牌成功，剩余容量:", len(tokens))
}

sync.WaitGroup 与 Mutex 的使用场景

Goroutine 和 Channel 解决了并发执行与通信问题，但还需要解决两个关键问题：等待所有并发任务完成和保护共享资源的互斥访问。Go 标准库 sync 包提供了 WaitGroup 和 Mutex 来分别应对这两个场景。

2.3 sync.WaitGroup：等待 Goroutine 集合完成

WaitGroup 是一个计数信号量，用于等待一组 Goroutine 全部结束。其 API 极其简洁：

func main() {
    var wg sync.WaitGroup
    urls := []string{"/api/v1/limit", "/api/v1/breaker", "/api/v1/retry"}

    for _, url := range urls {
        wg.Add(1) // 每个任务启动前加 1
        go func(u string) {
            defer wg.Done() // 任务完成时减 1
            fmt.Printf("处理请求: %s\n", u)
            time.Sleep(50 * time.Millisecond)
        }(url)
    }

    wg.Wait() // 等待所有请求处理完成
    fmt.Println("所有请求处理完毕，进入下一阶段")
}

2.4 sync.Mutex：保护共享资源的互斥锁

当多个 Goroutine 并发读写同一共享变量时，必须使用 Mutex 保证原子性。Mutex 提供 Lock() 和 Unlock() 两个方法，形成临界区保护。

type Counter struct {
    mu    sync.Mutex
    value int64
}

func (c *Counter) Incr() {
    c.mu.Lock()
    c.value++ // 临界区：一次只有一个 Goroutine 能执行
    c.mu.Unlock()
}

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

2.5 三种并发原语的选型对比