并发模型

这一课你将能做到

1. 用 go 关键字启动 goroutine，并用 sync.WaitGroup 正确等待一组任务结束
2. 用 channel 在 goroutine 间传递数据，说清无缓冲与有缓冲、close 与 range 的规则
3. 组合 select、worker pool、Mutex、context 解决四类典型并发问题

为什么要学

并发是 Go 的招牌，也是面试的重灾区。Java 起一个线程默认 1MB 栈、创建销毁都昂贵；Go 的 goroutine 初始栈只有约 2KB，由运行时调度（GMP 模型）在少量系统线程上复用百万级任务，go f() 一行就能启动。

Go 的并发哲学一句话：不要通过共享内存来通信，而要通过通信来共享内存。channel 是通信的管道，Mutex 是共享的锁，context 是取消的开关——这一课把这套工具链全部打通。

先建立图像

           go f() 启动
main ────────────────▶ goroutine A ─┐
        │                            │ channel（先进先出管道）
        │            goroutine B ────┤  ch <- 数据  （发送）
        ▼                            │  v := <-ch   （接收）
   主流程继续跑，不等 goroutine         └──▶ 另一端取到数据

有缓冲 channel：    [ ][ ][ ][ ]   装满后发送方阻塞
无缓冲 channel：    两端必须同时就位，像接力交接

两个心智要点：go 之后主流程立刻往下走，不等待；channel 是「带锁的队列 + 阻塞语义」，收发两端速度不一致时自动等待。

跟着做

步骤 1：第一次启动 goroutine——以及它的陷阱

package main

import (
	"fmt"
	"time"
)

func say(msg string) {
	fmt.Println("goroutine 说:", msg)
}

func main() {
	go say("hello")            // 启动后立刻返回
	go say("world")
	time.Sleep(time.Second)    // 丑陋的等待，仅演示
	fmt.Println("main 结束")
}

问题：main 一退出，所有 goroutine 被直接终止。time.Sleep 猜等待时间不可靠，工程做法是 WaitGroup。

步骤 2：sync.WaitGroup——等待一组任务

package main

import (
	"fmt"
	"sync"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done() // 3. 结束时 Done（务必 defer，防 panic 漏调）
	fmt.Printf("worker %d 干活\n", id)
}

func main() {
	var wg sync.WaitGroup
	for i := 1; i <= 3; i++ {
		wg.Add(1)          // 1. 启动前 Add
		go worker(i, &wg)  // 2. 必须传指针！传值会拷贝计数器
	}
	wg.Wait() // 4. 阻塞直到计数归零
	fmt.Println("全部完成")
}

三步口诀：启动前 Add，结束 defer Done，主流程 Wait。最常见的事故是 go worker(i, wg) 传了值——计数器被拷贝，Done 减的是副本，Wait 永远等不到。

步骤 3：无缓冲 channel——同步接力

package main

import "fmt"

func main() {
	ch := make(chan int) // 无缓冲

	go func() {
		ch <- 42 // 发送：等接收方就位才继续
		fmt.Println("已送出 42")
	}()

	v := <-ch // 接收：等发送方送来
	fmt.Println("收到:", v)

	// 由于发送阻塞到接收完成，这里"已送出"一定在"收到"之后打印
}