Goroutine Select

Mon, 12 Oct 2026 09:55:20 +0800

Go `select` 详解与可运行示例

一、本质：select 是什么

select 是 Go 里唯一的多路 channel 操作原语。它让一个 goroutine 同时等待多个 channel 操作，哪个先就绪就走哪个。没有它，你要么串行阻塞在单个 channel 上，要么自己开 goroutine 轮询。

一句话定位：switch 是对值的分支，select 是对通道就绪状态的分支。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


select {
case v := <-ch1:    // ch1 有数据可读
    handle(v)
case ch2 <- x:      // ch2 有接收者就绪
    // 发送成功
case <-time.After(time.Second):  // 超时
    // ...
default:            // 所有 case 都没就绪
    // 不阻塞，立即走这里
}

二、语法与语义规则

规则 1：case 必须是 channel 操作

合法：<-ch、ch <- v、v, ok := <-ch。非法：普通表达式、函数调用（case f(): 不行）、常量比较。

规则 2：多个 case 同时就绪时，伪随机选一个

1
2
3
4


select {
case <-ch1:
case <-ch2:
}

两个都就绪时，runtime 用 cheaprandn 随机选。这是有意设计，避免固定顺序导致某个 case 永远饿死。所以不要依赖 select 的分支顺序写业务逻辑。

规则 3：没有 `default` 时，全部不就绪则阻塞当前 goroutine

阻塞期间 goroutine 进 _Gwaiting，会让出 P，M 去跑别的 G。不占 CPU。

规则 4：有 `default` 时，全部不就绪则立即执行 default

default 让 select 变成非阻塞的。这是"尝试一次，不行就算了"的标准写法。

规则 5：`select {}` 永久阻塞

空 select 永远阻塞，用于让 main goroutine 永不退出（配合其他 goroutine 干活）：

1
2
3
4


func main() {
    go worker()
    select {}   // 永久阻塞，不会死锁 panic（因为有 worker 在跑）
}

但如果没有任何其他 goroutine，select {} 会触发 fatal error: all goroutines are asleep - deadlock。

规则 6：nil channel 上的 case 永远不就绪

1
2
3
4
5


var ch chan int   // nil
select {
case <-ch:        // 这个 case 永远不会被选中
    ...
}

这是禁用某个分支的利器（后文详述）。

规则 7：`break` 跳出的是 `select`，不是外层 `for`

1
2
3
4
5
6


for {
    select {
    case <-done:
        break      // ⚠️ 只跳出 select，for 继续转
    }
}

要用 return、goto、或者带标签的 break loop 才能跳出循环。

三、运行时机制：`selectgo`

编译器把 select 编译成对 runtime.selectgo 的调用。核心流程：

selectgo(cases):
  ① 生成 pollorder（随机打乱的 case 顺序）
  ② 生成 lockorder（按 channel 地址排序，防死锁）
  ③ 第一轮：按 pollorder 遍历，逐个尝试非阻塞收发
      ├─ 有就绪的 → 直接执行该 case，返回
      └─ 没有 → 继续
  ④ 有 default → 执行 default，返回
  ⑤ 没有 default → 把所有 case 的 sudog 挂到各 channel 的等待队列上
      → gopark() 阻塞
  ⑥ 被某个 channel 的就绪事件唤醒 → 从队列摘除所有 sudog → 返回被选中的 case

两个关键设计：

pollorder 随机：保证公平，避免固定顺序饥饿
lockorder 按地址排序：多个 case 涉及多个 channel 的锁时，统一按地址顺序加锁，避免两个 goroutine 以相反顺序加锁导致死锁

case 数量上限：select 最多 65536 个 case（uint16 索引），实际中远用不到，但要知道有这个上限。

性能：无就绪 case 且需要阻塞时，每个 case 都要分配 sudog、挂队列，开销明显高于单个 channel 操作。select 适合"少数几个 channel"，不适合"海量 channel 轮询"。

四、经典模式（每个都可直接 `go run`）

示例 1：基础多路复用

 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


package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() {
		time.Sleep(100 * time.Millisecond)
		ch1 <- "来自 ch1"
	}()
	go func() {
		time.Sleep(200 * time.Millisecond)
		ch2 <- "来自 ch2"
	}()

	for i := 0; i < 2; i++ {
		select {
		case v := <-ch1:
			fmt.Println("收到:", v)
		case v := <-ch2:
			fmt.Println("收到:", v)
		}
	}
}

预期输出：

收到: 来自 ch1
收到: 来自 ch2

要点：select 同时等两个 channel，谁先到处理谁。ch1 先发（100ms），所以先走 ch1 分支。

示例 2：超时控制（最常用）

 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


package main

import (
	"fmt"
	"time"
)

func slowOp() <-chan string {
	ch := make(chan string)
	go func() {
		time.Sleep(2 * time.Second)   // 模拟慢操作
		ch <- "结果"
	}()
	return ch
}

func main() {
	start := time.Now()

	select {
	case v := <-slowOp():
		fmt.Println("成功:", v, "耗时:", time.Since(start))
	case <-time.After(500 * time.Millisecond):
		fmt.Println("超时! 耗时:", time.Since(start))
	}
}

预期输出：

超时! 耗时: 500.xxxms

要点：

time.After(d) 返回一个 channel，d 之后收到一个值
慢操作 2 秒，超时 500ms，select 走超时分支
注意：time.After 底层 timer 在触发前不会释放，高频循环里用 time.NewTimer + Reset 更省资源（后文陷阱详述）

示例 3：非阻塞收发（`default`）

 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
30
31
32
33
34
35
36
37
38
39


package main

import "fmt"

func main() {
	ch := make(chan int, 1)

	// 第一次：channel 空，发送成功
	select {
	case ch <- 1:
		fmt.Println("发送 1 成功")
	default:
		fmt.Println("发送 1 失败（通道满）")
	}

	// 第二次：channel 已满（cap=1），发送走 default
	select {
	case ch <- 2:
		fmt.Println("发送 2 成功")
	default:
		fmt.Println("发送 2 失败（通道满）")
	}

	// 接收：有数据，成功
	select {
	case v := <-ch:
		fmt.Println("接收到:", v)
	default:
		fmt.Println("通道空，无数据")
	}

	// 再次接收：空了，走 default
	select {
	case v := <-ch:
		fmt.Println("接收到:", v)
	default:
		fmt.Println("通道空，无数据")
	}
}

预期输出：

发送 1 成功
发送 2 失败（通道满）
接收到: 1
通道空，无数据

要点：default 让操作变成"尝试一次"——这就是"非阻塞发送/接收"的标准写法。

示例 4：优雅退出（context + 信号）

 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
30
31
32
33
34
35
36
37


package main

import (
	"context"
	"fmt"
	"time"
)

func worker(ctx context.Context, id int) {
	ticker := time.NewTicker(200 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			fmt.Printf("worker %d 退出: %v\n", id, ctx.Err())
			return
		case <-ticker.C:
			fmt.Printf("worker %d 干活中...\n", id)
		}
	}
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())

	for i := 1; i <= 3; i++ {
		go worker(ctx, i)
	}

	time.Sleep(700 * time.Millisecond)
	fmt.Println(">>> 发出取消信号")
	cancel()

	time.Sleep(500 * time.Millisecond)
	fmt.Println(">>> main 退出")
}

预期输出（时序大致如此）：

worker 1 干活中...
worker 2 干活中...
worker 3 干活中...
worker 1 干活中...
worker 2 干活中...
worker 3 干活中...
worker 1 干活中...
worker 2 干活中...
worker 3 干活中...
>>> 发出取消信号
worker 1 退出: context canceled
worker 2 退出: context canceled
worker 3 退出: context canceled
>>> main 退出

要点：

ctx.Done() 是广播：cancel() 后所有 select 在这个 case 上的 goroutine 同时收到
这是 Go 服务里标准退出模式：每个长任务都 select 监听 ctx.Done()
defer ticker.Stop() 防止资源泄漏

示例 5：用 nil channel 动态禁用分支

 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


package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)
	ch2 := make(chan string)

	go func() { ch1 <- "ch1 数据" }()
	go func() { ch2 <- "ch2 数据" }()

	// 先启用两个通道
	c1, c2 := ch1, ch2

	for i := 0; i < 2; i++ {
		select {
		case v := <-c1:
			fmt.Println("处理:", v)
			c1 = nil   // 禁用 ch1 分支，后续 select 忽略它
		case v := <-c2:
			fmt.Println("处理:", v)
			c2 = nil
		}
	}
	fmt.Println("两个通道都已处理完毕")
}

预期输出：

处理: ch1 数据
处理: ch2 数据
两个通道都已处理完毕

要点：c1 = nil 之后，case v := <-c1 在 select 里永远不就绪——这是动态开关分支的标准技巧。常见于"关闭某个数据源后只从剩下的源读"的场景。

示例 6：优先级 select（防止低优先级饿死）

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


package main

import (
	"fmt"
	"time"
)

func main() {
	high := make(chan string, 10)
	low := make(chan string, 10)

	// 塞入数据
	for i := 0; i < 3; i++ {
		high <- fmt.Sprintf("高优先级-%d", i)
	}
	for i := 0; i < 5; i++ {
		low <- fmt.Sprintf("低优先级-%d", i)
	}
	close(high)

	for i := 0; i < 8; i++ {
		// 第一层 select：优先尝试 high
		select {
		case v, ok := <-high:
			if ok {
				fmt.Println("处理:", v)
				continue
			}
			// high 已关闭，走下面
		default:
			// high 没就绪，落到第二层
		}

		// 第二层 select：处理 low 或等待 high
		select {
		case v, ok := <-high:
			if ok {
				fmt.Println("处理:", v)
			}
		case v := <-low:
			fmt.Println("处理:", v)
		}
		time.Sleep(10 * time.Millisecond)
	}
}

预期输出（前 3 条必为高优先级）：

处理: 高优先级-0
处理: 高优先级-1
处理: 高优先级-2
处理: 低优先级-0
处理: 低优先级-1
处理: 低优先级-2
处理: 低优先级-3
处理: 低优先级-4

要点：select 本身不支持优先级，但可以用两层 select 模拟：第一层带 default 尝试高优先级，没就绪再进第二层等。代价是代码复杂，且默认分支有 CPU 空转风险——第二层里的 time.Sleep 就是为了缓解空转（生产代码里更推荐用 time.Ticker 或合理设置 default 的退出条件）。

示例 7：for-select 循环（最常见的结构）

 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
30
31
32
33
34
35
36
37
38


package main

import (
	"fmt"
	"time"
)

func main() {
	jobs := make(chan int, 5)
	done := make(chan struct{})

	// 消费者
	go func() {
		for {
			select {
			case j, ok := <-jobs:
				if !ok {
					fmt.Println("jobs 已关闭，消费者退出")
					return
				}
				fmt.Println("处理任务:", j)
			case <-done:
				fmt.Println("收到退出信号，消费者退出")
				return
			}
		}
	}()

	// 生产 3 个任务
	for i := 1; i <= 3; i++ {
		jobs <- i
	}

	time.Sleep(100 * time.Millisecond)
	close(done)   // 触发消费者退出
	time.Sleep(100 * time.Millisecond)
	fmt.Println("main 退出")
}

预期输出：

处理任务: 1
处理任务: 2
处理任务: 3
收到退出信号，消费者退出
main 退出

要点：

for { select { ... } } 是 Go 并发代码的基本骨架
每个 case 都要有明确的退出路径（return 或 break loop）
用 v, ok := <-ch 感知关闭
不要用 break 跳出 for——break 只跳 select（前文规则 7）

示例 8：select 随机性演示

 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


package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan int, 1)
	ch2 := make(chan int, 1)
	ch1 <- 1
	ch2 <- 2

	counts := map[int]int{}
	for i := 0; i < 1000; i++ {
		select {
		case v := <-ch1:
			counts[v]++
			ch1 <- 1
		case v := <-ch2:
			counts[v]++
			ch2 <- 2
		}
	}
	fmt.Printf("ch1 被选中 %d 次, ch2 被选中 %d 次\n", counts[1], counts[2])
	time.Sleep(10 * time.Millisecond)
}

预期输出（数字接近 500/500）：

ch1 被选中 约500 次, ch2 被选中 约500 次

要点：两个 channel 始终有数据，select 随机选。跑多次会发现比例接近 1:1，但不是严格交替。不要依赖 select 的顺序写逻辑。

示例 9：合并多个 channel（fan-in）

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


package main

import (
	"fmt"
	"sync"
	"time"
)

func producer(name string, n int) <-chan string {
	ch := make(chan string)
	go func() {
		defer close(ch)
		for i := 0; i < n; i++ {
			ch <- fmt.Sprintf("%s-%d", name, i)
			time.Sleep(50 * time.Millisecond)
		}
	}()
	return ch
}

func merge(chs ...<-chan string) <-chan string {
	out := make(chan string)
	var wg sync.WaitGroup
	for _, ch := range chs {
		wg.Add(1)
		go func(c <-chan string) {
			defer wg.Done()
			for v := range c {
				out <- v
			}
		}(ch)
	}
	go func() {
		wg.Wait()
		close(out)
	}()
	return out
}

func main() {
	a := producer("A", 3)
	b := producer("B", 3)

	for v := range merge(a, b) {
		fmt.Println("收到:", v)
	}
	fmt.Println("全部完成")
}

预期输出（A/B 交错，顺序不定）：

收到: A-0
收到: B-0
收到: A-1
收到: B-1
收到: A-2
收到: B-2
全部完成

要点：这是不依赖 select 的 fan-in——每个源一个 goroutine 往同一个 out 写。sync.WaitGroup + close 是上一轮讨论的"多生产者关闭"标准模式。merge 内部每个 goroutine 的 for range 是阻塞读，天然实现了"谁有数据谁先写"，效果等价于 select 多路复用，但代码更清晰、可扩展（N 个源不用写 N 个 case）。

示例 10：带缓冲 channel + select 的批处理

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


package main

import (
	"fmt"
	"time"
)

func main() {
	events := make(chan int, 100)

	// 生产事件
	go func() {
		for i := 1; i <= 20; i++ {
			events <- i
			time.Sleep(20 * time.Millisecond)
		}
		close(events)
	}()

	ticker := time.NewTicker(100 * time.Millisecond)
	defer ticker.Stop()

	var batch []int
	for {
		select {
		case v, ok := <-events:
			if !ok {
				if len(batch) > 0 {
					fmt.Println("最后一批:", batch)
				}
				fmt.Println("全部完成")
				return
			}
			batch = append(batch, v)
			if len(batch) >= 5 {
				fmt.Println("批量处理:", batch)
				batch = batch[:0]
			}
		case <-ticker.C:
			if len(batch) > 0 {
				fmt.Println("定时刷新:", batch)
				batch = batch[:0]
			}
		}
	}
}

预期输出（大致）：

定时刷新: [1 2 3 4]
批量处理: [5 6 7 8 9]
批量处理: [10 11 12 13 14]
批量处理: [15 16 17 18 19]
最后一批: [20]
全部完成

要点：select 同时监听"数据到达"和"定时器触发"，实现双条件批处理——要么凑够 5 个，要么 100ms 到了就刷。这是生产级批量处理的标准骨架（日志聚合、数据库批量写都用这个模式）。

五、陷阱清单

⚠️ 陷阱 1：`time.After` 在循环里的资源泄漏

1
2
3
4
5
6
7
8
9


// ❌ 每秒泄漏一个 timer
for {
    select {
    case v := <-ch:
        handle(v)
    case <-time.After(time.Second):   // 每次循环都创建新 timer
        timeout()
    }
}

time.After 创建的 timer 在触发前不会被 GC，即使 select 走了别的分支。高频循环里会累积大量 timer，内存持续上涨。

修复：用 time.NewTimer + 手动 Reset：

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


// ✅ 复用 timer
timer := time.NewTimer(time.Second)
defer timer.Stop()
for {
    if !timer.Stop() {
        <-timer.C
    }
    timer.Reset(time.Second)
    select {
    case v := <-ch:
        handle(v)
    case <-timer.C:
        timeout()
    }
}

⚠️ 陷阱 2：`default` 导致 CPU 空转

1
2
3
4
5
6
7
8
9


// ❌ 死循环空转，CPU 100%
for {
    select {
    case v := <-ch:
        handle(v)
    default:
        // 什么都不做，立即进入下一轮
    }
}

default 让 select 不阻塞，循环转得飞快，CPU 打满。

修复：要么去掉 default（阻塞等），要么在 default 里加 runtime.Gosched() 或 time.Sleep，要么用 time.Ticker 节流。

⚠️ 陷阱 3：`break` 跳出的是 select，不是 for

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


// ❌ break 只跳出 select，for 继续转
for {
    select {
    case <-done:
        break          // 以为跳出 for，其实只跳出 select
    }
}
// ✅ 用 return 或标签
loop:
for {
    select {
    case <-done:
        break loop
    }
}

⚠️ 陷阱 4：关闭的 channel 在 select 里一直就绪

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


ch := make(chan int)
close(ch)
for {
    select {
    case v, ok := <-ch:
        if !ok {
            return   // 必须判断 ok，否则 select 每次都选这个 case
        }
    case x := <-other:
        handle(x)
    }
}

关闭的 channel 永远可以立即读到零值，所以 case <-ch 在 select 里永远就绪，会疯狂抢走其他 case 的机会。必须用 v, ok := 判断，ok 为 false 时把 ch 设为 nil 或退出。

⚠️ 陷阱 5：nil channel 用于禁用，但别拿它做"空转"

1
2
3
4
5


var ch chan int   // nil
select {
case <-ch:        // 永远不就绪 ✅ 用来禁分支
case <-other:     // 正常工作
}

这是特性不是 bug。但如果所有 case 都是 nil channel 且没有 default，就永久阻塞（和 select {} 一样）。

⚠️ 陷阱 6：select 里对同一 channel 多个 case

1
2
3
4
5


// ❌ 两个 case 操作同一 channel，行为混乱
select {
case v := <-ch:
case ch <- 1:
}

虽然语法合法，但实际语义很难推理（一读一写同时竞争），生产代码应避免。每个 channel 在 select 里最多出现一次。

⚠️ 陷阱 7：select 的 case 太多

超过 65536 个 case 编译期报错。即使没到上限，case 越多，selectgo 的轮询和锁开销越大。“等很多个 channel” 应该用 fan-in 模式聚合成一个 channel，而不是写几百个 case。

六、性能与最佳实践速查

场景	推荐写法
等少数几个 channel	`select` 直接多路复用
等很多个 channel	fan-in 聚合（示例 9），别写 N 个 case
超时	`time.After`（低频）/ `time.NewTimer`（循环内）
非阻塞尝试	`select + default`
优先级	两层 select（示例 6），注意 default 空转
动态启用/禁用分支	把变量设为 `nil`
循环等待 + 退出	`for { select { case <-ctx.Done(): return; ... } }`
关闭的 channel	`v, ok := <-ch` 判断 ok，ok=false 时退出或置 nil
广播退出	`close(done)` 或 `cancel()`，不要发 N 个值

七、总结

心智模型三句话：

select 是 channel 的 switch——对"哪个 channel 就绪"做分支，不是对值做分支
就绪随机选——这是公平性保证，不要依赖分支顺序
default 改阻塞语义——有 default 就是"尝试一次"，没 default 就是"阻塞等待"

四条铁律：

每个 case 都要有退出路径（return / break label / 置 nil），否则就是泄漏或死循环
关闭的 channel 永远就绪，必须 v, ok := 判断
default 要慎用，空转 CPU 是生产事故的常见源头
循环里的 time.After 会泄漏 timer，用 NewTimer + Reset

一句话：

select 让你一个 goroutine 同时监听多个通道，是 Go 写"响应式"逻辑的基石——超时、取消、多路复用、非阻塞尝试、优先级调度，全都靠它。但它的随机性和"关闭通道永远就绪"两个特性，决定了你必须在每个 case 里显式处理"这个分支是否还该活着"，否则不是死锁就是 CPU 打满。

十二、select 底层原理（简要）

编译器会把 select 转换为运行时调用：

1
2


// 伪代码
func selectgo(cas0 *scase, order0 *uint16, ncases int) (int, bool)

流程：

生成 scase 数组，每个 case 描述一个 channel 操作
加锁所有涉及 channel（按地址排序避免死锁）
遍历所有 case，找出就绪的
若多个就绪 → 用 fastrand 随机选一个
若都未就绪 → 当前 goroutine 挂起到所有 channel 的等待队列
有 default 则直接走 default

要点：

有 default：不挂起，直接返回
无 default：将当前 goroutine 加入所有相关 channel 的 sendq/recvq
被唤醒后从所有队列移除自己

十三、实战：完整示例 - 带超时、取消、重试的任务调度

 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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


package main

import (
    "context"
    "fmt"
    "math/rand"
    "time"
)

func fetch(ctx context.Context, id int) (string, error) {
    result := make(chan string, 1)

    go func() {
        // 模拟网络请求
        time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
        result <- fmt.Sprintf("数据-%d", id)
    }()

    select {
    case r := <-result:
        return r, nil
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    for i := 1; i <= 5; i++ {
        select {
        case <-ctx.Done():
            fmt.Println("整体超时，退出")
            return
        default:
        }

        data, err := fetch(ctx, i)
        if err != nil {
            fmt.Println("任务", i, "失败:", err)
            continue
        }
        fmt.Println("任务", i, "成功:", data)
    }

    fmt.Println("全部完成")
}

十四、select 使用清单

场景	写法
等待多个 channel	`select { case <-a: case <-b: }`
非阻塞读取	加 `default`
超时控制	`case <-time.After(d):`
循环超时	`time.NewTimer` + `Reset`
退出信号	`case <-done:` 配合 `close(done)`
取消	`case <-ctx.Done():`
禁用某 case	把 channel 置 nil
合并多 channel	for + select + `ch = nil`
高优先级	嵌套 select

十五、最佳实践总结

✅ 循环内用 select + for 持续监听
✅ 超时优先用 context.Context，time.After 仅用于单次
✅ 退出用 close(done) 广播，不要发送多个值
✅ ch = nil 是禁用 case 的惯用技巧
✅ 多 case 随机是特性，不是 bug；要优先级用嵌套 select
❌ 循环里别用 time.After，会泄漏定时器
❌ 别在 select 中 close 已经关闭的 channel
❌ 无限循环 + 无 default + 所有 channel 阻塞 → deadlock

进一步展开：

select 源码解析（runtime.selectgo 的具体实现）
context 与 select 配合的深入用法
高并发场景下 select 的性能优化与替代方案

Select on 山高月小

Goroutine Select

Go select 详解与可运行示例

一、本质：select 是什么

二、语法与语义规则

规则 1：case 必须是 channel 操作

规则 2：多个 case 同时就绪时，伪随机选一个

规则 3：没有 default 时，全部不就绪则阻塞当前 goroutine

规则 4：有 default 时，全部不就绪则立即执行 default

规则 5：select {} 永久阻塞

规则 6：nil channel 上的 case 永远不就绪

规则 7：break 跳出的是 select，不是外层 for

三、运行时机制：selectgo

四、经典模式（每个都可直接 go run）

示例 1：基础多路复用

示例 2：超时控制（最常用）

示例 3：非阻塞收发（default）

示例 4：优雅退出（context + 信号）

示例 5：用 nil channel 动态禁用分支

示例 6：优先级 select（防止低优先级饿死）

示例 7：for-select 循环（最常见的结构）

示例 8：select 随机性演示

示例 9：合并多个 channel（fan-in）

示例 10：带缓冲 channel + select 的批处理

五、陷阱清单

⚠️ 陷阱 1：time.After 在循环里的资源泄漏

⚠️ 陷阱 2：default 导致 CPU 空转

⚠️ 陷阱 3：break 跳出的是 select，不是 for

⚠️ 陷阱 4：关闭的 channel 在 select 里一直就绪

⚠️ 陷阱 5：nil channel 用于禁用，但别拿它做"空转"

⚠️ 陷阱 6：select 里对同一 channel 多个 case

⚠️ 陷阱 7：select 的 case 太多

六、性能与最佳实践速查

七、总结

十二、select 底层原理（简要）

十三、实战：完整示例 - 带超时、取消、重试的任务调度

十四、select 使用清单

十五、最佳实践总结

Go `select` 详解与可运行示例

规则 3：没有 `default` 时，全部不就绪则阻塞当前 goroutine

规则 4：有 `default` 时，全部不就绪则立即执行 default

规则 5：`select {}` 永久阻塞

规则 7：`break` 跳出的是 `select`，不是外层 `for`

三、运行时机制：`selectgo`

四、经典模式（每个都可直接 `go run`）

示例 3：非阻塞收发（`default`）

⚠️ 陷阱 1：`time.After` 在循环里的资源泄漏

⚠️ 陷阱 2：`default` 导致 CPU 空转

⚠️ 陷阱 3：`break` 跳出的是 select，不是 for