2. 竞态条件：数据竞争的定义、竞态条件示例、go race detector 工具使用

2.1 数据竞争的定义

数据竞争（Data Race）是并发编程中最常见且最危险的错误之一。根据 Go 内存模型（The Go Memory Model）的官方定义：当两个或多个 goroutine 同时访问同一个内存位置，且其中至少有一个是写操作，并且这些访问没有通过同步机制（如互斥锁、原子操作或 channel）进行协调时，就发生了数据竞争。

数据竞争的核心特征可以归纳为以下三点：

• 并发访问：多个 goroutine 在时间上重叠地访问同一变量。
• 至少一个写操作：如果所有访问都是读操作，则不会产生数据竞争。
• 缺乏同步：没有使用任何同步原语来保证操作的原子性或可见性。

2.2 竞态条件示例

下面是一个经典的银行账户并发取款示例，展示了数据竞争如何导致竞态条件（Race Condition）：

package main

import (
    "fmt"
    "sync"
)

type Account struct {
    Balance int
}

func (a *Account) Withdraw(amount int) {
    // 竞态条件：读取-修改-写入 非原子操作
    if a.Balance >= amount {
        a.Balance -= amount
    }
}

func main() {
    acc := &Account{Balance: 1000}
    var wg sync.WaitGroup

    // 启动 10 个 goroutine 同时取款 800
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            acc.Withdraw(800)
        }()
    }

    wg.Wait()
    fmt.Printf("最终余额: %d\n", acc.Balance)
}

上述代码中，Withdraw 方法的 if a.Balance >= amount 和 a.Balance -= amount 是两条独立的指令。当多个 goroutine 并发执行时，可能出现以下时序：

1. Goroutine A 读取 Balance = 1000，判断 1000 >= 800，进入 if 分支。
2. Goroutine B 读取 Balance = 1000（A 尚未写入），判断 1000 >= 800，也进入 if 分支。
3. Goroutine A 执行减法：Balance = 1000 - 800 = 200。
4. Goroutine B 执行减法：Balance = 1000 - 800 = 200（覆盖了 A 的结果）。

最终余额为 200，但逻辑上应该只允许一次成功取款，余额应为 200 或 1000（如果第一次取款失败）。这就是典型的竞态条件——程序的行为依赖于 goroutine 的调度顺序。

2.3 go race detector 工具使用

Go 语言内置了强大的竞态检测工具——Race Detector。它基于 ThreadSanitizer（TSan） 技术，在运行时动态检测数据竞争。使用方式非常简单：在 go build、go run 或 go test 命令后加上 -race 标志即可启用。

2.3.1 基本用法

2.3.2 检测输出解读

当 Race Detector 发现数据竞争时，会输出详细的报告，包含以下关键信息：

==================
WARNING: DATA RACE
Read at 0x00c0000a4010 by goroutine 7:
  main.(*Account).Withdraw()
      /path/to/main.go:12 +0x64

Previous write at 0x00c0000a4010 by goroutine 6:
  main.(*Account).Withdraw()
      /path/to/main.go:12 +0x7c

Goroutine 7 (running) created at:
  main.main()
      /path/to/main.go:22 +0x98

Goroutine 6 (finished) created at:
  main.main()
      /path/to/main.go:22 +0x98
==================

报告结构解析：

• WARNING: DATA RACE：检测到数据竞争的警告标识。
• Read/Write at ... by goroutine N：发生竞争的读写操作位置及所属 goroutine。
• Previous write/read at ... by goroutine M：与之冲突的另一个操作。
• Goroutine N created at：goroutine 的创建堆栈，帮助定位源头。

2.3.3 常见误报与局限性

2.4 修复竞态条件的标准方法

针对上述银行账户示例，有三种主流的修复方案：

// 方案一：使用互斥锁
type SafeAccount struct {
    mu      sync.Mutex
    Balance int
}

func (a *SafeAccount) Withdraw(amount int) {
    a.mu.Lock()
    defer a.mu.Unlock()
    if a.Balance >= amount {
        a.Balance -= amount
    }
}

// 方案二：使用原子操作（适合简单场景）
type AtomicAccount struct {
    Balance int64
}

func (a *AtomicAccount) Withdraw(amount int64) {
    // 需要 CompareAndSwap 循环实现安全减法
    for {
        old := atomic.LoadInt64(&a.Balance)
        if old < amount {
            return
        }
        if atomic.CompareAndSwapInt64(&a.Balance, old, old-amount) {
            return
        }
    }
}