Go 语言并发编程：Goroutine 与 Channel

Go 并发模型

Go 的并发哲学："不要通过共享内存来通信，而要通过通信来共享内存"

Goroutine：轻量级线程

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    for i := 0; i < 5; i++ {
        fmt.Printf("Hello %d\n", i)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go sayHello() // 启动 goroutine
    
    time.Sleep(1 * time.Second) // 等待完成
    fmt.Println("Done")
}

Goroutine 特点

• 轻量级：栈大小仅 2KB，可创建百万级
• 自动调度：Go 运行时管理
• 并发执行：多核并行

Channel：类型安全的通信管道

package main

import "fmt"

func main() {
    ch := make(chan int)
    
    go func() {
        ch <- 42 // 发送
    }()
    
    value := <-ch // 接收
    fmt.Println(value) // 42
}

Channel 类型

// 无缓冲 channel（同步）
ch1 := make(chan int)

// 缓冲 channel（异步）
ch2 := make(chan int, 10)

// 只读 channel
func producer(ch chan<- int) {
    ch <- 1
}

// 只写 channel
func consumer(ch <-chan int) {
    <-ch
}

select：多路复用

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    go func() { ch1 <- 1 }()
    go func() { ch2 <- 2 }()
    
    select {
    case v1 := <-ch1:
        fmt.Println("ch1:", v1)
    case v2 := <-ch2:
        fmt.Println("ch2:", v2)
    case <-time.After(1 * time.Second):
        fmt.Println("timeout")
    }
}

Worker Pool 模式

func worker(id int, jobs <-chan int, results chan<- int) {
    for job := range jobs {
        results <- job * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    
    // 启动 3 个 worker
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    
    // 发送任务
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    
    // 收集结果
    for r := 1; r <= 5; r++ {
        <-results
    }
}

sync 包：同步原语

import "sync"

// WaitGroup - 等待多个 goroutine 完成
var wg sync.WaitGroup
wg.Add(2)
go func() {
    defer wg.Done()
    // 工作
}()
wg.Wait()

// Mutex - 互斥锁
var mu sync.Mutex
var counter int

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

// Once - 只执行一次
var once sync.Once
once.Do(func() {
    // 初始化代码
})

最佳实践

1. 避免 goroutine 泄漏 - 确保所有 goroutine 能退出
2. 使用 context 控制超时 - context.WithTimeout
3. channel 及时关闭 - 发送方关闭
4. 不要共享可变状态 - 优先使用 channel 通信

Go 的并发模型简洁强大，是构建高并发系统的首选！