📚 课程目录第1章 Go并发模型

一、Go 并发模型：Goroutine 与 Channel 基础、CSP 模型原理、并发与并行的区别

1.1 并发与并行的本质区别

在进入 Go 并发模型之前，必须厘清两个最容易被混淆的核心概念：并发（Concurrency）与并行（Parallelism）。Go 之父 Rob Pike 曾用一句经典的话概括："并发是结构，并行是执行。"

维度	并发（Concurrency）	并行（Parallelism）
定义	多个任务在逻辑上同时进行（交替执行）	多个任务在物理上同时进行（真正同时运行）
硬件依赖	单核 CPU 即可实现（时间片轮转）	必须多核 CPU 或多处理器
关注点	任务分解、组合、协调（设计层面）	计算加速、吞吐量（执行层面）
Go 中的体现	Goroutine 的调度与通信	GOMAXPROCS 控制 OS 线程数
类比	一个人交替做多件事（煮水、切菜、看火）	多个人各做一件事（一人煮水、一人切菜）

  性能调优启示： 并发不保证加速，但能提升响应性和结构清晰度；并行才直接提升吞吐量。调优时先确认瓶颈是并发结构不合理，还是并行度不足。

1.2 CSP 模型原理

Go 的并发哲学源自 CSP（Communicating Sequential Processes，通信顺序进程）模型，由 Tony Hoare 于 1978 年提出。CSP 的核心思想是：不要通过共享内存来通信，而要通过通信来共享内存。

实体（Process/Entity）：独立的计算单元，拥有自己的状态。
通信（Communication）：实体之间通过通道（Channel）传递消息，而非直接访问对方内存。
同步（Synchronization）：发送与接收操作默认是阻塞的，天然实现同步。

Go 将 CSP 模型简化为两个核心原语：Goroutine（轻量级实体）和 Channel（通信管道）。与传统的共享内存 + 锁模型相比，CSP 模型在大规模并发场景下能显著降低心智负担和死锁风险。

面试高频点： CSP 与 Actor 模型的区别——CSP 的 Channel 是匿名的，发送方不知道接收方是谁；Actor 模型的消息有明确目标地址。Go 的 Channel 更接近 CSP 原意。

1.3 Goroutine：轻量级并发单元

Goroutine 是 Go 运行时管理的用户态线程，初始栈空间仅 2~4 KB，创建和销毁开销极低（微秒级）。一个 Go 进程可以轻松创建数十万甚至百万个 Goroutine，这是 OS 线程无法比拟的。

特性	Goroutine	OS 线程
创建开销	~2 KB 栈 + 微秒级	~1 MB 栈 + 毫秒级
调度方式	Go 运行时（GMP 模型）协作式 + 抢占式	内核调度器（完全抢占式）
上下文切换	~几十纳秒（用户态）	~微秒级（内核态，涉及系统调用）
最大数量	百万级（受内存限制）	数千（受内核限制）
标识	无内置 ID（设计哲学：不依赖身份）	有 PID/TID

// 启动一个 Goroutine 的三种常见方式
package main

import (
    "fmt"
    "time"
)

func say(msg string) {
    fmt.Println(msg)
}

func main() {
    // 方式1：直接 go 函数调用
    go say("Hello from Goroutine")

    // 方式2：匿名函数
    go func() {
        fmt.Println("Anonymous Goroutine")
    }()

    // 方式3：闭包捕获外部变量（注意变量逃逸）
    for i := 0; i < 3; i++ {
        go func(n int) {
            fmt.Printf("Goroutine %d\n", n)
        }(i) // 显式传值，避免闭包陷阱
    }

    time.Sleep(100 * time.Millisecond) // 等待 Goroutine 执行（仅示例，生产应使用 WaitGroup）
}

常见陷阱： 循环中启动 Goroutine 时，如果匿名函数直接引用循环变量 i，所有 Goroutine 可能共享同一个变量地址，导致输出重复值。务必通过参数传值或创建局部副本。

1.4 Channel：Goroutine 之间的通信桥梁

Channel 是 Go 中类型安全的通信管道，遵循 CSP 模型的"通信顺序进程"原则。Channel 分为无缓冲和有缓冲两种，其行为差异直接影响并发程序的同步语义。

类型	创建方式	发送行为	接收行为	典型场景
无缓冲	`make(chan T)`	阻塞直到有接收方就绪	阻塞直到有发送方就绪	同步、信号传递、goroutine 间握手
有缓冲	`make(chan T, N)`	缓冲区未满时非阻塞，满则阻塞	缓冲区非空时非阻塞，空则阻塞	解耦生产-消费、限流、批量处理

// 无缓冲 Channel：同步通信
func unbufferedDemo() {
    ch := make(chan string)
    go func() {
        ch <- "ping" // 发送，阻塞直到 main goroutine 接收
    }()
    msg := <-ch // 接收，阻塞直到发送完成
    fmt.Println(msg) // 输出: ping
}

// 有缓冲 Channel：异步通信
func bufferedDemo() {
    ch := make(chan int, 3)
    ch <- 1 // 非阻塞
    ch <- 2 // 非阻塞
    ch <- 3 // 非阻塞
    // ch <- 4 // 缓冲区满，阻塞
    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
    fmt.Println(<-ch) // 3
}

1.5 select 多路复用：CSP 的守卫命令

select 语句是 CSP 模型中守卫命令（Guarded Command）的 Go 实现，允许一个 Goroutine 同时等待多个 Channel 操作。当多个 case 同时就绪时，Go 运行时伪随机选择一个执行，避免饥饿。

// select 基本用法：超时控制 + 多路监听
func selectDemo() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() {
        time.Sleep(50 * time.Millisecond)
        ch1 <- "from ch1"
    }()
    go func() {
        time.Sleep(100 * time.Millisecond)
        ch2 <- "from ch2"
    }()

    select {
    case msg1 := <-ch1:
        fmt.Println("Received:", msg1)
    case msg2 := <-ch2:
        fmt.Println("Received:", msg2)
    case <-time.After(80 * time.Millisecond):
        fmt.Println("Timeout!") // 超时保护
    default:
        fmt.Println("No channel ready") // 非阻塞轮询
    }
}

  性能要点： select 中的 default 分支会使整个 select 变为非阻塞，适用于轮询场景。但过度使用非阻塞 select 会导致 CPU 空转，应配合 time.Sleep 或退避策略。

1.6 本章小结：并发模型全景

Go 的并发模型以 CSP 为理论基础，通过 Goroutine 和 Channel 提供了简洁、安全、高效的并发编程范式。理解以下三点是后续调优的基石：

并发 ≠ 并行：设计时关注并发结构，运行时通过 GOMAXPROCS 控制并行度。
Goroutine 是轻量级用户态线程：创建百万级 Goroutine 是常态，但要注意避免 Goroutine 泄漏。
Channel 是 CSP 通信的核心：无缓冲 Channel 用于同步，有缓冲 Channel 用于解耦；select 实现多路复用和超时控制。