本章深入解析Go语言并发编程核心机制，涵盖调度原理、通信模式及工程实践，结合性能优化与陷阱规避策略。

6.1 Goroutine基础

6.1.1 创建与调度

// 启动goroutine
go func() {
    fmt.Println("Async task")
}()

// 携带参数
msg := "hello"
go func(m string) {
    fmt.Println(m)
}(msg)

核心特性

• 轻量级线程：初始栈大小 2KB（可动态扩缩，最大1GB）
• GMP调度模型：

• Goroutine：用户态任务
• Machine：系统线程（与CPU核心绑定）
• Processor：逻辑处理器（任务队列管理）

• 抢占式调度：基于信号（Go 1.14+）实现公平调度

性能调优

# 查看调度器信息
GODEBUG=schedtrace=1000,scheddetail=1 go run main.go

6.2 Channel通信

6.2.1 通道类型

ch1 := make(chan int)    // 无缓冲通道（同步）
ch2 := make(chan int, 5) // 缓冲通道（异步队列）

6.2.2 操作语义

底层实现

type hchan struct {
    qcount   uint           // 队列元素总数
    dataqsiz uint           // 缓冲区大小
    buf      unsafe.Pointer // 环形缓冲区指针
    sendx    uint           // 发送索引
    recvx    uint           // 接收索引
    lock     mutex          // 互斥锁
}

最佳实践

• 优先使用无缓冲通道实现强同步逻辑
• 生产-消费场景使用缓冲通道解耦
• 遵循"发送方关闭通道"原则避免panic

6.3 Select语句

6.3.1 多路复用

select {
case v := <-ch1:
    fmt.Println("ch1:", v)
case ch2 <- 42:
    fmt.Println("sent to ch2")
case <-time.After(1 * time.Second):
    fmt.Println("timeout")
default:
    fmt.Println("no activity")
}

6.3.2 高级模式

• 循环监听：

for {
    select {
    case <-done:
        return
    case v := <-ch:
        process(v)
    }
}

• 优先级处理：

select {
case job := <-highPriorityChan:
    handleHighPriority(job)
default:
    select {
    case job := <-lowPriorityChan:
        handleLowPriority(job)
    case <-time.After(time.Minute):
        handleTimeout()
    }
}

注意事项

• 多个case同时就绪时随机选择执行
• 空的select语句会永久阻塞

6.4 同步原语(sync包)

6.4.1 互斥锁

var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

6.4.2 读写锁

var cache = make(map[string]string)
var rwMu sync.RWMutex

func get(key string) string {
    rwMu.RLock()
    defer rwMu.RUnlock()
    return cache[key]
}

func set(key, value string) {
    rwMu.Lock()
    defer rwMu.Unlock()
    cache[key] = value
}

6.4.3 其他同步工具

性能对比

• Mutex：适合低频写操作
• RWMutex：读多写少场景性能提升 5-10倍
• Atomic：无锁操作性能最佳（但仅限简单类型）

6.5 并发模式

6.5.1 扇入/扇出模式

// 扇入：合并多个输入通道
func merge(chs ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan int)
    
    for _, ch := range chs {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for n := range c {
                out <- n
            }
        }(ch)
    }
    
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

6.5.2 工作池模式

func workerPool(tasks <-chan Task, workers int) {
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for task := range tasks {
                processTask(id, task)
            }
        }(i)
    }
    wg.Wait()
}

6.5.3 流水线模式

func pipeline(in <-chan int) <-chan int {
    // 阶段1：数据过滤
    stage1 := make(chan int)
    go func() {
        defer close(stage1)
        for n := range in {
            if n%2 == 0 {
                stage1 <- n
            }
        }
    }()
    
    // 阶段2：数据处理
    stage2 := make(chan int)
    go func() {
        defer close(stage2)
        for n := range stage1 {
            stage2 <- n * 2
        }
    }()
    
    return stage2
}

6.6 上下文(Context)

6.6.1 核心功能

// 创建上下文
ctx, cancel := context.WithCancel(context.Background())
defer cancel()

// 传递上下文
go func(ctx context.Context) {
    select {
    case <-ctx.Done():
        fmt.Println("canceled")
    }
}(ctx)

6.6.2 派生上下文

6.6.3 实践规范

• 服务端必须处理Context.Done()：

func HandleRequest(ctx context.Context) {
    select {
    case <-ctx.Done():
        return ctx.Err()
    case result := <-db.Query():
        return result
    }
}

• Value使用规范：

• 使用自定义类型作为key避免冲突：

type userKey struct{}
ctx = context.WithValue(ctx, userKey{}, user)

• 仅传递请求范围数据，避免滥用

总结

本章系统阐述了Go并发编程的核心机制，重点包含：

1. GMP调度模型的运行时行为分析
2. Channel内存模型与hchan结构实现细节
3. 锁竞争优化策略与性能对比
4. 生产级并发模式的实现方案
5. Context树形传播机制的正确使用

建议通过以下实践加深理解：

• 使用go test -race检测竞态条件
• 通过pprof分析goroutine泄漏
• 实现带超时控制的分布式任务调度系统
• 对比不同同步原语在百万次操作下的性能差异