1
2
3
4

runtime.NumCPU()          // 逻辑 CPU 数
runtime.NumGoroutine()    // 当前 goroutine 数（泄漏排查常用）
runtime.GOMAXPROCS(0)     // 查询当前值（传 0 表示只查询）
runtime.GOMAXPROCS(4)     // 设置

1
2
3
4
5
6
7
8

// ① 具名函数
go worker(ctx)

// ② 闭包（常带参数）
go func(id int) { process(id) }(i)

// ③ 方法
go s.serve(ctx)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 🛑 泄漏：ch 无缓冲，没人接收，goroutine 永久阻塞
func leak() {
	ch := make(chan int)
	go func() { ch <- 42 }()   // 这个 goroutine 永远不会结束
	// 函数返回，ch 不可达，但 goroutine 还挂在 channel 上
}

// ✅ 修复 1：加缓冲
ch := make(chan int, 1)

// ✅ 修复 2：用 select + ctx 提供退出路径
select {
case ch <- 42:
case <-ctx.Done():
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

channel 三种状态的读写行为（记这张图就够）

【无缓冲 make(chan T)】同步交接
   发送方 ──阻塞──┐                ┌──阻塞── 接收方
                  │  必须有对面    │
                  └──► 值直接传递 ─┘
   len=0 cap=0，无任何缓冲

【有缓冲 make(chan T, 2)】异步队列
   ┌──────────────────────────────┐
   │ [ 1 ][ 2 ][   ]              │  队列
   └──────────────────────────────┘
      ▲            ▲         ▲
      │            │         │
   发送满则阻塞   取走即空   缓冲未满 → 发送不阻塞
   len = 当前元素数    cap = 队列长度

【已关闭 close(ch)】
   ┌──────────────────────────────┐
   │ [ 1 ][ 2 ]  ✗ 不能写          │
   └──────────────────────────────┘
   写 → 💥 panic: send on closed channel
   读 → 先吐完剩余值，再返回 零值 + ok=false ✅
       （这就是 for range ch 能退出的原因）

【nil channel（零值）】
   var ch chan int
   写 → 永久阻塞   读 → 永久阻塞
   在 select 里用它 = 永久禁用该分支 🔥

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println("len/cap:", len(ch), cap(ch), <-ch, <-ch)   // len=2 cap=2

c := make(chan int, 2)
c <- 1
close(c)
v, ok := <-c
fmt.Println("recv after close:", v, ok)   // 1 true  ← 还有数据
v2, ok2 := <-c
fmt.Println("drained:", v2, ok2)          // 0 false  ← 取空了，零值 + false

1
2
3

len/cap: 2 2 1 2
recv after close: 1 true
drained: 0 false

1
2
3

// 三种 panic 场景（实测均可被 recover 捕获，但生产中不该出现）
ch <- 1    // 向已关闭的 channel 发送 → panic: send on closed channel
close(ch)  // 重复关闭 → panic: close of closed channel

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

func producer(out chan<- int) {   // 只能发送
	for i := range 3 {
		out <- i
	}
	close(out)
}

func consumer(in <-chan int) {    // 只能接收
	for v := range in {
		fmt.Println(v)
	}
}

ch := make(chan int)
go producer(ch)   // 双向 channel 可隐式转成单向 ✅
consumer(ch)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

select {
case v := <-chA:
	// chA 就绪
case chB <- value:
	// chB 可发送
case <-ctx.Done():
	// 取消或超时 🔥
case <-time.After(time.Second):
	// 超时
default:
	// 没有一个就绪，立即走这里（非阻塞）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

chA := make(chan string, 1)
chB := make(chan string, 1)
chA <- "from A"

for range 2 {
	select {
	case v := <-chA:
		fmt.Println("got", v, "→ 之后禁用 A")
		chA = nil      // 🔥 该分支从此永不就绪
	case v := <-chB:
		fmt.Println("got", v)
	default:
		fmt.Println("没有就绪的 channel")
	}
}

1
2

got from A → 之后禁用 A
没有就绪的 channel

1
2
3
4
5
6
7
8
9

// ⚠️ 在循环里这么写会累积定时器（Go 1.23 前的经典泄漏）
for {
	select {
	case v := <-ch:
		use(v)
	case <-time.After(time.Second):   // 每轮都新建一个 Timer
		return
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

timer := time.NewTimer(time.Second)
defer timer.Stop()
for {
	timer.Reset(time.Second)     // ✅ 复用同一个 Timer，避免每轮分配
	select {
	case v := <-ch:
		use(v)
	case <-timer.C:
		return
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func worker(ctx context.Context, jobs <-chan Job) error {
	for {
		select {
		case <-ctx.Done():
			return ctx.Err()       // 🔥 必须有的退出路径
		case job, ok := <-jobs:
			if !ok {
				return nil          // 通道关闭，正常结束
			}
			if err := handle(job); err != nil {
				return err
			}
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func gen(ctx context.Context, nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		defer close(out)              // 🔥 确保接收方 range 能结束
		for _, n := range nums {
			select {
			case out <- n:
			case <-ctx.Done():
				return
			}
		}
	}()
	return out
}

for n := range gen(ctx, 1, 2, 3) {
	fmt.Println(n)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

func merge(ctx context.Context, chans ...<-chan int) <-chan int {
	out := make(chan int)
	var wg sync.WaitGroup
	for _, c := range chans {
		wg.Go(func() {                 // 🆕 1.25：Add(1) + Done() 已内含
			for v := range c {
				select {
				case out <- v:
				case <-ctx.Done():
					return
				}
			}
		})
		// ⚠️ 千万不要再写 defer wg.Done()：Go 已经替你调用，重复调用会让计数器变负而 panic
	}
	go func() { wg.Wait(); close(out) }()   // 🔥 全部完成后关闭
	return out
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

实测（场景一，panic 发生在 wg.Go 起的 goroutine 里，main 无法 recover）：
  Wait 返回了（提前返回或正常返回）
  panic: sync: negative WaitGroup counter
      sync.(*WaitGroup).Add(...)   waitgroup.go:118
      sync.(*WaitGroup).Done(...)  waitgroup.go:156
      sync.(*WaitGroup).Go.func1.1()  waitgroup.go:256
  exit status 2

实测（场景二，多余 Done 在 Wait 之后，可 recover）：
  main 内 recover: sync: negative WaitGroup counter
  场景2 结束，进程未崩溃

1
2
3
4
5
6
7
8

sem := make(chan struct{}, 10)   // 最多 10 个并发
for _, task := range tasks {
	sem <- struct{}{}            // 获取令牌（满了就阻塞）
	go func() {
		defer func() { <-sem }() // 释放令牌
		process(task)
	}()
}

1
2
3
4
5
6

done := make(chan struct{})   // 只用于关闭，不传数据 🔥
go func() {
	defer close(done)
	work()
}()
<-done

1
2
3
4

func main() {
	ch := make(chan int)
	<-ch    // 所有 goroutine 都睡了
}

1

fatal error: all goroutines are asleep - deadlock!