深入理解Go语言并发模式：从基础到高级实践-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00956/article/details/148362849

深入理解Go语言并发模式：从基础到高级实践

advanced-go-programming-book :books: 《Go语言高级编程》开源图书，涵盖CGO、Go汇编语言、RPC实现、Protobuf插件实现、Web框架实现、分布式系统等高阶主题(完稿) 项目地址: https://gitcode.com/gh_mirrors/ad/advanced-go-programming-book

Go语言以其简洁高效的并发模型而闻名，本文将系统性地介绍Go语言中常见的并发模式，帮助开发者掌握并发编程的核心思想与实践技巧。

并发与并行的本质区别

在开始探讨并发模式之前，我们需要明确一个基本概念：并发不是并行。这是Go语言并发编程中最重要的哲学基础之一。

并发关注的是程序的设计层面，它描述的是程序结构能够处理多个同时存在的任务的能力。并发程序完全可以在单核CPU上顺序执行。
并行关注的是程序的运行层面，它描述的是程序在多个CPU核心上真正同时执行多个任务。

Go语言的并发模型基于CSP（Communicating Sequential Processes）理论，其核心思想是"通过通信来共享内存，而不是通过共享内存来通信"。这一理念从根本上避免了传统多线程编程中常见的竞态条件和锁竞争问题。

基础并发模式

1. 并发Hello World

让我们从一个简单的并发示例开始，了解Go语言并发的基本工作方式：

func main() {
    done := make(chan int, 1)  // 带缓存的管道

    go func() {
        fmt.Println("Hello, 世界")
        done <- 1
    }()

    <-done
}

这个例子展示了几个关键点：

使用go关键字启动goroutine
通过channel实现goroutine间的同步
带缓冲的channel可以避免死锁

2. 使用WaitGroup管理多个goroutine

当需要等待多个goroutine完成时，sync.WaitGroup是更优雅的选择：

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            fmt.Println("Hello, 世界")
        }()
    }

    wg.Wait()
}

WaitGroup内部使用计数器实现，Add增加计数，Done减少计数，Wait阻塞直到计数器归零。

经典并发模式实践

1. 生产者-消费者模式

生产者-消费者是并发编程中最常见的模式之一，Go语言实现起来非常简洁：

func Producer(out chan<- int) {
    for i := 0; ; i++ {
        out <- i
    }
}

func Consumer(in <-chan int) {
    for v := range in {
        fmt.Println(v)
    }
}

func main() {
    ch := make(chan int, 64)
    go Producer(ch)
    go Producer(ch)
    go Consumer(ch)
    time.Sleep(5 * time.Second)
}

关键点：

使用带缓冲的channel作为队列
可以启动多个生产者和消费者
通过channel自动处理同步问题

2. 发布-订阅模式

发布-订阅模式(pub/sub)允许消息被广播到多个订阅者：

type Publisher struct {
    subscribers map[chan interface{}]func(v interface{}) bool
    mutex       sync.RWMutex
}

func (p *Publisher) Subscribe(topic func(v interface{}) bool) chan interface{} {
    ch := make(chan interface{}, 10)
    p.mutex.Lock()
    p.subscribers[ch] = topic
    p.mutex.Unlock()
    return ch
}

func (p *Publisher) Publish(v interface{}) {
    p.mutex.RLock()
    defer p.mutex.RUnlock()
    
    for ch, topic := range p.subscribers {
        if topic == nil || topic(v) {
            ch <- v
        }
    }
}

这个实现展示了：

线程安全的订阅者管理
基于过滤器的主题订阅
并发安全的发布机制

高级并发控制

1. 限制并发数

有时我们需要限制并发操作的数量，可以通过带缓冲的channel实现：

var limit = make(chan int, 3)

func worker() {
    limit <- 1    // 获取令牌
    defer func() { <-limit }()  // 释放令牌
    
    // 工作代码
}

func main() {
    for _, w := range work {
        go worker(w)
    }
}

这种模式常用于：

限制数据库连接数
控制API调用频率
管理资源密集型任务

2. 赢者为王模式

当我们需要从多个来源获取数据，但只需要最快的结果时：

func main() {
    ch := make(chan string, 3)
    
    go func() { ch <- searchBySource1(query) }()
    go func() { ch <- searchBySource2(query) }()
    go func() { ch <- searchBySource3(query) }()
    
    fmt.Println(<-ch)  // 获取最快返回的结果
}

这种模式特别适合：

多镜像下载
冗余服务查询
容错性要求高的场景

优雅退出goroutine

管理goroutine的生命周期是并发编程中的重要课题。以下是几种推荐做法：

1. 使用done channel

func worker(done <-chan bool) {
    for {
        select {
        case <-done:
            return
        default:
            // 正常工作
        }
    }
}

func main() {
    done := make(chan bool)
    go worker(done)
    
    time.Sleep(time.Second)
    close(done)  // 广播退出信号
}

2. 结合context包

Go 1.7引入的context包提供了更完善的取消机制：

func worker(ctx context.Context, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for {
        select {
        case <-ctx.Done():
            return
        default:
            // 正常工作
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go worker(ctx, &wg)
    }
    
    time.Sleep(time.Second)
    cancel()  // 通知所有worker退出
    wg.Wait() // 等待所有worker完成
}

context的优势：