Golang中Race Condition问题的分析与复现（附play.golang.org演示）

以下是一个有趣的定义。

同步 基本上意味着你一次只能执行一件事。异步 意味着你可以同时执行多件事，并且不必等待当前任务完成就可以继续执行下一个任务。

在Go语言中，竞态条件（Race Condition）是指多个goroutine在没有正确同步的情况下并发访问共享数据，导致程序行为不可预测。Todd McCleod提供的代码示例展示了典型的竞态条件问题。

代码分析

原示例代码（简化版）：

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {
	counter := 0
	const gs = 100
	var wg sync.WaitGroup
	wg.Add(gs)

	for i := 0; i < gs; i++ {
		go func() {
			v := counter
			runtime.Gosched()
			v++
			counter = v
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println("counter:", counter)
}

runtime包解析

runtime包提供了与Go运行时系统交互的功能。在竞态条件分析中，关键函数是：

// runtime.Gosched() 让出当前goroutine的执行权
runtime.Gosched()

// 查看逻辑CPU数量
fmt.Println("CPU cores:", runtime.NumCPU())

// 设置最大并发执行的goroutine数量
runtime.GOMAXPROCS(1)

// 查看当前goroutine数量
fmt.Println("Goroutines:", runtime.NumGoroutine())

runtime.Gosched()主动让出CPU时间片，使其他goroutine有机会执行，这有助于暴露竞态条件。

sync包解析

sync包提供了基本的同步原语。解决竞态条件的关键组件：

// 使用互斥锁解决竞态条件
var mu sync.Mutex
mu.Lock()
counter++
mu.Unlock()

// 使用原子操作解决竞态条件
import "sync/atomic"
var counter int64
atomic.AddInt64(&counter, 1)

// WaitGroup等待goroutine完成
var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    // 工作代码
}()
wg.Wait()

竞态条件复现代码

package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {
	// 设置使用所有CPU核心
	runtime.GOMAXPROCS(runtime.NumCPU())

	// 竞态条件演示
	fmt.Println("=== Race Condition Demo ===")
	demoRaceCondition()

	// 使用互斥锁解决
	fmt.Println("\n=== Mutex Solution ===")
	demoMutexSolution()

	// 使用原子操作解决
	fmt.Println("\n=== Atomic Solution ===")
	demoAtomicSolution()
}

func demoRaceCondition() {
	counter := 0
	const gs = 100
	var wg sync.WaitGroup
	wg.Add(gs)

	for i := 0; i < gs; i++ {
		go func() {
			v := counter
			runtime.Gosched() // 增加竞态条件发生概率
			v++
			counter = v
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Printf("Expected: 100, Got: %d\n", counter)
}

func demoMutexSolution() {
	counter := 0
	const gs = 100
	var wg sync.WaitGroup
	var mu sync.Mutex
	wg.Add(gs)

	for i := 0; i < gs; i++ {
		go func() {
			mu.Lock()
			v := counter
			runtime.Gosched()
			v++
			counter = v
			mu.Unlock()
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Printf("Expected: 100, Got: %d\n", counter)
}

func demoAtomicSolution() {
	var counter int64
	const gs = 100
	var wg sync.WaitGroup
	wg.Add(gs)

	for i := 0; i < gs; i++ {
		go func() {
			atomic.AddInt64(&counter, 1)
			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Printf("Expected: 100, Got: %d\n", counter)
}

检测竞态条件

使用Go内置的竞态检测器：

go run -race main.go
go build -race main.go

竞态检测器会报告类似这样的错误：

WARNING: DATA RACE
Read at 0x00c00001c0a8 by goroutine 7:
  main.demoRaceCondition.func1()
      /path/to/main.go:30 +0x47

Previous write at 0x00c00001c0a8 by goroutine 6:
  main.demoRaceCondition.func1()
      /path/to/main.go:32 +0x63

理解runtime和sync包的方法

1. 查看官方文档：

go doc runtime
go doc sync
go doc sync/atomic

1. 查看源码：

# 查看runtime包源码
cd $(go env GOROOT)/src/runtime

# 查看sync包源码
cd $(go env GOROOT)/src/sync

1. 编写测试代码：

package main

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

func exploreRuntime() {
	fmt.Println("GOROOT:", runtime.GOROOT())
	fmt.Println("GOOS:", runtime.GOOS)
	fmt.Println("Compiler:", runtime.Compiler)
	
	// 内存统计
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	fmt.Printf("Alloc = %v MiB\n", m.Alloc/1024/1024)
}

func exploreSync() {
	// Once示例
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}
	
	for i := 0; i < 5; i++ {
		go func() {
			once.Do(onceBody)
		}()
	}
	time.Sleep(time.Second)
}

竞态条件的核心问题是并发访问共享状态缺乏同步。runtime包提供运行时控制，sync包提供同步原语。正确使用这些工具可以避免竞态条件，确保并发程序的正确性。