Jasper Jiang'Blog

Go 原子操作

6 min

Go 原子操作

Atomic Operations

1. 什么是原子操作

  • 原子操作（Atomic Operations）是在计算机系统中，能够被一次性执行完成而不会被中断的操作。在多线程或并发编程中，原子操作确保了在执行过程中不会发生线程上下文切换，从而避免竞态条件（race condition）。

2. 为什么需要原子操作

  • 在并发编程中，当多个 goroutine 同时访问和修改共享资源时，可能会导致竞态条件。使用原子操作可以确保这些操作是安全的，即使在多核处理器上也不会出现并发问题。

3. Go 语言中的原子操作

  • Go 语言标准库的 sync/atomic 包提供了一组函数，用于对整数类型和指针类型进行原子操作。这些函数可以确保对共享变量的读写操作是原子的。

3.1. 原子操作的基本函数

  • atomic.AddInt32、atomic.AddInt64：对 int32 和 int64 类型的变量进行原子加操作。
  • atomic.LoadInt32、atomic.LoadInt64：原子地读取 int32 和 int64 类型的变量。
  • atomic.StoreInt32、atomic.StoreInt64：原子地写入 int32 和 int64 类型的变量。
  • atomic.CompareAndSwapInt32、atomic.CompareAndSwapInt64：原子地比较并交换 int32 和 int64 类型的变量。
  • atomic.SwapInt32、atomic.SwapInt64：原子地交换 int32 和 int64 类型的变量。

3.2. 常用原子操作函数

  1. Add：原子加

    atomic.AddInt32(&counter, 1)
atomic.AddInt64(&counter64, 1)

  2. Load：原子读

    val := atomic.LoadInt32(&counter)
val64 := atomic.LoadInt64(&counter64)

  3. Store：原子写

    atomic.StoreInt32(&counter, 42)
atomic.StoreInt64(&counter64, 42)

  4. CompareAndSwap：原子比较并交换

    old := int32(42)
new := int32(100)
swapped := atomic.CompareAndSwapInt32(&counter, old, new)

  5. Swap：原子交换

    old := atomic.SwapInt32(&counter, 100)
old64 := atomic.SwapInt64(&counter64, 100)

3.3. 示例代码

以下是一个使用 sync/atomic 包实现并发安全计数器的示例：

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var counter int32

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    atomic.AddInt32(&counter, 1)
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }

    wg.Wait()
    fmt.Println("Final counter value:", counter)
}

  • 在这个示例中：

    • 使用 atomic.AddInt32 函数对计数器进行原子加操作，确保多个 goroutine 并发执行时不会出现竞态条件。

    • sync.WaitGroup 用于等待所有 goroutine 完成。

    • 需要注意的是：

      • 操作类型匹配：确保使用与变量类型匹配的原子操作函数。例如，int32 类型的变量应使用 atomic.AddInt32 等函数。
      • 性能考量：虽然原子操作提供了简单的并发安全保证，但在某些情况下（如频繁的复杂操作），使用锁（Mutex）可能更合适。
      • 内存对齐：确保使用原子操作的变量是 64 位对齐的，特别是在 32 位系统上，否则可能会导致崩溃。

4. 注意事项

4.1 原子操作的优势和局限性

优势

  1. 低开销：原子操作通常比锁更高效，因为它们避免了上下文切换和锁竞争。
  2. 简单操作：适用于简单的计数器、标志位等单个变量的原子读写操作。

局限性

  1. 功能有限：原子操作只适用于基本的整数和指针操作，无法处理复杂的临界区。
  2. 易读性差：代码的可读性和可维护性较低，复杂的原子操作逻辑可能难以理解和维护。
  3. 不可组合：多个原子操作无法保证操作的整体性，可能导致逻辑上的竞态条件。

4.2 锁的优势和局限性

优势

  1. 通用性强：适用于任意类型的数据保护和复杂的临界区操作。
  2. 代码可读性好：锁可以使代码逻辑更加清晰，容易理解和维护。
  3. 可组合性强：多个操作可以在锁保护下组合成一个原子操作，避免逻辑上的竞态条件。

4.3 局限性

  1. 性能开销：锁可能导致上下文切换、锁竞争和死锁等问题，降低性能。
  2. 复杂性增加：锁的使用需要小心处理，避免死锁、锁的过度使用等问题。

适用场景

原子操作适用场景

  1. 简单计数器：例如并发安全的计数器、统计数据等。
  2. 状态标志：例如并发安全的布尔标志、标志位等。

8. 总结

sync/atomic 包提供了一组强大的工具来确保对共享变量的操作是原子的，从而避免竞态条件。它们适用于需要高效、安全地操作单个变量的场景。在复杂的并发场景下，可能需要结合其他同步原语（如 Mutex、WaitGroup）使用，以实现更复杂的同步逻辑。

大二