Go内存模型中的并发安全实现

题目

Go内存模型中的并发安全实现

信息

• 类型：问答
• 难度：⭐⭐

考点

Go内存模型,并发安全,同步原语

快速回答

在Go中实现并发安全的计数器需要：

• 使用sync.Mutex或sync/atomic包保证原子操作
• 通过同步机制建立happens-before关系
• 避免数据竞争（data race）

问题场景

以下代码实现了一个并发计数器，但存在数据竞争问题：

type Counter struct {
    value int
}

func (c *Counter) Increment() {
    c.value++
}

func (c *Counter) Value() int {
    return c.value
}

// 并发调用示例
func main() {
    counter := &Counter{}
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }
    wg.Wait()
    fmt.Println(counter.Value()) // 结果可能小于1000
}

问题原因

• 数据竞争：c.value++是非原子操作（包含读-改-写三步）
• 内存可见性：缺少同步机制导致goroutine间内存更新不可见
• 违反Go内存模型：未建立happens-before关系，操作顺序无法保证

解决方案

方案1：使用互斥锁（Mutex）

type Counter struct {
    mu    sync.Mutex
    value int
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

原理：

• Mutex创建happens-before关系，保证临界区操作原子性
• Unlock操作同步到内存，确保对其他goroutine可见

方案2：使用原子操作（atomic）

type Counter struct {
    value int64
}

func (c *Counter) Increment() {
    atomic.AddInt64(&c.value, 1)
}

func (c *Counter) Value() int64 {
    return atomic.LoadInt64(&c.value)
}

原理：

• atomic包提供硬件级原子指令
• Load/Store操作保证内存可见性和顺序性

最佳实践

• 优先使用原子操作：简单计数器场景性能更高
• Mutex适用复杂逻辑：当需要保护多个字段或复杂操作时
• 避免过度同步：如只读操作可使用RLock()
• 检测工具：使用go run -race检测数据竞争

常见错误

• 忘记解锁Mutex导致死锁
• 复制包含Mutex的结构体（需使用指针接收者）
• 原子操作与普通操作混用造成数据不一致

扩展知识

• happens-before原则：Go内存模型的核心规则，定义操作可见性顺序
• 同步原语：sync.Once, sync.WaitGroup, channel等都会建立happens-before关系
• 内存屏障：底层通过CPU内存屏障指令实现可见性保证

最终验证代码

// 使用atomic的线程安全计数器
func main() {
    counter := &Counter{}
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }
    wg.Wait()
    fmt.Println(counter.Value()) // 稳定输出1000
}