Go 语言的并发模型是其区别于其他编程语言的重要特性之一，它以简洁高效的方式解决了现代编程中多核处理器利用和高并发场景的需求。

一、并发与并行：概念与区别

在理解 Go 的并发模型之前，需要明确并发与并行的差异：

并发：指程序同时管理多个任务的能力，这些任务可能在交替执行
并行：指多个任务在不同处理器上同时执行

Go 的并发模型基于 CSP（通信顺序进程）范式，通过 goroutine 和通道实现高效的并发编程。Go 运行时的调度器会将 goroutine 分配到逻辑处理器上执行，每个逻辑处理器绑定一个操作系统线程。

二、goroutine：轻量级线程的实践

1. 创建与调度

goroutine 是 Go 并发的基本单元，创建方式非常简洁：

package mainimport ("fmt""time"
)func main() {// 创建goroutine执行任务go printAlphabet("a")go printAlphabet("A")// 等待任务完成time.Sleep(2 * time.Second)
}func printAlphabet(prefix string) {for char := 'a'; char < 'a'+26; char++ {fmt.Printf("%s: %c\n", prefix, char)time.Sleep(100 * time.Millisecond)}
}

2. 调度器与逻辑处理器

Go 调度器的核心组件包括：

全局运行队列：存放等待执行的 goroutine
本地运行队列：每个逻辑处理器对应的运行队列
网络轮询器：处理网络 I/O 相关的 goroutine

通过runtime.GOMAXPROCS函数可以设置逻辑处理器的数量：

// 设置使用2个逻辑处理器
runtime.GOMAXPROCS(2)

三、竞争状态：问题检测与解决方案

1. 竞争状态的产生

当多个 goroutine 同时访问共享资源时，可能引发竞争状态：

package mainimport ("fmt""sync"
)var counter int
var wg sync.WaitGroupfunc main() {wg.Add(2)go increment("A")go increment("B")wg.Wait()fmt.Println("Final counter:", counter) // 预期输出4，实际可能小于4
}func increment(identifier string) {defer wg.Done()for i := 0; i < 2; i++ {value := counter// 模拟上下文切换fmt.Printf("%s: Reading counter as %d\n", identifier, value)counter = value + 1}
}

2. 竞争检测工具

Go 提供了内置的竞争检测工具：

go build -race your_program.go
./your_program

3. 解决方案：原子操作与互斥锁

原子操作示例：

package mainimport ("atomic""fmt""sync"
)var counter int64
var wg sync.WaitGroupfunc main() {wg.Add(2)go safeIncrement("A")go safeIncrement("B")wg.Wait()fmt.Println("Final counter:", atomic.LoadInt64(&counter))
}func safeIncrement(identifier string) {defer wg.Done()for i := 0; i < 2; i++ {atomic.AddInt64(&counter, 1)fmt.Printf("%s: Incremented counter\n", identifier)}
}

互斥锁示例：

package mainimport ("fmt""sync"
)var counter int
var mutex sync.Mutex
var wg sync.WaitGroupfunc main() {wg.Add(2)go safeIncrement("A")go safeIncrement("B")wg.Wait()fmt.Println("Final counter:", counter)
}func safeIncrement(identifier string) {defer wg.Done()for i := 0; i < 2; i++ {mutex.Lock()counter++fmt.Printf("%s: Incremented counter to %d\n", identifier, counter)mutex.Unlock()}
}

四、通道：goroutine 间的通信桥梁

1. 无缓冲通道：同步通信

无缓冲通道要求发送和接收操作同时准备好，典型应用场景如任务同步：

package mainimport ("fmt""sync"
)func main() {court := make(chan int)var wg sync.WaitGroupwg.Add(2)// 启动两个选手go player("Nadal", court, &wg)go player("Djokovic", court, &wg)// 发球开始比赛court <- 1// 等待比赛结束wg.Wait()close(court)
}func player(name string, court chan int, wg *sync.WaitGroup) {defer wg.Done()for {// 等待接球ball, ok := <-courtif !ok {fmt.Printf("%s 获胜!\n", name)return}// 模拟击球fmt.Printf("%s 击球: %d\n", name, ball)ball++// 随机决定是否失误if ball%10 == 0 {fmt.Printf("%s 失误!\n", name)close(court)return}// 回击球court <- ball}
}

2. 有缓冲通道：异步通信

有缓冲通道允许发送和接收操作不同步，适合任务池场景：

package mainimport ("fmt""sync""time"
)const taskCount = 10func main() {// 创建有缓冲通道作为任务池tasks := make(chan int, taskCount)var wg sync.WaitGroupwg.Add(3) // 3个工作goroutine// 启动工作goroutinefor worker := 1; worker <= 3; worker++ {go workerTask(worker, tasks, &wg)}// 提交任务for task := 1; task <= taskCount; task++ {tasks <- taskfmt.Printf("任务 %d 已提交\n", task)}// 关闭通道表示任务提交完成close(tasks)// 等待所有任务完成wg.Wait()
}func workerTask(worker int, tasks chan int, wg *sync.WaitGroup) {defer wg.Done()for task := range tasks {fmt.Printf("工作者 %d 处理任务 %d\n", worker, task)time.Sleep(500 * time.Millisecond)}
}