专注于 Golang 相关文章和资料的开源项目 [go-home] ，欢迎关注！

Go语言的CSP（Communicating Sequential Processes）模型是其并发编程的核心哲学，彻底改变了我们思考并发的方式。

1. CSP到底是什么？

想象一个工厂：传统方式是多个工人共用一个工作台（共享内存），需要排队等待；CSP方式是工人之间通过传送带传递物品（通信），每个工人专注自己的工作。

CSP核心理念：把并发看作独立的顺序进程通过消息传递进行通信，而不是多个进程访问共享数据。

// 问题场景：多个goroutine需要累加一个计数器

// 传统方式：共享内存 + 锁
var sharedCounter int        // 共享变量
var mutex sync.Mutex         // 保护锁

func traditionalIncrement() {
    mutex.Lock()             // 获取锁
    sharedCounter++          // 修改共享变量  
    mutex.Unlock()           // 释放锁
}

// CSP方式：通过通信共享数据
func cspCounter() {
    ch := make(chan int, 1)
    ch <- 0                  // 初始值

    // 专门的计数器goroutine
    go func() {
        counter := <-ch      // 接收当前值
        counter++            // 修改
        ch <- counter        // 发送新值
    }()
}

区别在于：传统方式多个goroutine直接操作同一个变量；CSP方式数据只属于一个goroutine，其他goroutine通过消息获取。

2. 一个更清楚的对比例子

看一个银行账户的例子，多个人同时取钱：

// 传统共享内存方式：多个goroutine直接操作同一个账户变量
type BankAccount struct {
    balance int
    mutex   sync.Mutex
}

func (acc *BankAccount) Withdraw(amount int) bool {
    acc.mutex.Lock()
    defer acc.mutex.Unlock()
    
    if acc.balance >= amount {
        acc.balance -= amount    // 多个goroutine共享这个balance变量
        return true
    }
    return false
}

// CSP方式：账户数据只属于一个goroutine，其他通过消息请求
type WithdrawRequest struct {
    amount int
    result chan bool
}

func accountManager(balance int) chan WithdrawRequest {
    requests := make(chan WithdrawRequest)
    
    go func() {
        for req := range requests {
            if balance >= req.amount {
                balance -= req.amount    // 只有这个goroutine能修改balance
                req.result <- true
            } else {
                req.result <- false
            }
        }
    }()
    
    return requests
}

// 使用CSP方式取钱
func withdraw(requests chan WithdrawRequest, amount int) bool {
    result := make(chan bool)
    requests <- WithdrawRequest{amount: amount, result: result}
    return <-result    // 通过消息获取结果，而不是直接访问共享变量
}

关键区别：

  • 共享内存：多个goroutine都能直接访问balance变量
  • CSP：balance只属于账户管理器goroutine，其他goroutine通过发送消息来间接操作

3. goroutine：轻量级进程

goroutine是Go实现CSP的基础，比传统线程轻量得多：

// 创建goroutine非常简单
func main() {
    go sayHello()    // 启动一个goroutine
    go sayWorld()    // 再启动一个
    time.Sleep(time.Second)
}

func sayHello() { fmt.Println("Hello") }
func sayWorld() { fmt.Println("World") }

特点：

  • 初始栈大小仅2KB，可动态增长
  • 创建成本极低，可轻松创建百万级goroutine
  • Go运行时自动调度

4. channel：CSP模型的精髓

channel是实现CSP”通过通信共享内存”的关键工具：

// 无缓冲channel：同步通信（握手模式）
ch := make(chan string)

// 缓冲channel：异步通信（邮箱模式）
ch := make(chan string, 3)

// 发送和接收：数据在goroutine间流动，而非共享访问
go func() {
    ch <- "hello"    // 发送数据给另一个goroutine
}()

msg := <-ch         // 接收数据，实现信息共享

CSP精神体现：数据通过channel在goroutine间传递，每次只有一个goroutine”拥有”数据。

5. 经典CSP模式

生产者-消费者模式

func producer(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch <-chan int) {
    for num := range ch {
        fmt.Println("consumed:", num)
    }
}

func main() {
    ch := make(chan int, 5)
    go producer(ch)
    consumer(ch)
}

Worker Pool模式

func workerPool() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    // 启动3个worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送任务
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for a := 1; a <= 5; a++ {
        <-results
    }
}

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d processing job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

6. select：多路复用神器

select让你可以同时等待多个channel操作：

func main() {
    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "one"
    }()

    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "two"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        case <-time.After(3 * time.Second):
            fmt.Println("timeout")
        }
    }
}

7. CSP的优势

简单直观：代码逻辑清晰，易于理解和维护

避免竞态：通过channel通信，天然避免共享状态竞争

组合性强：可以轻松组合多个并发组件

性能优越：goroutine调度开销小，适合高并发场景