请说一下Go 原子操作有哪些？

八股文_Go机制 0 114

参考回答

在 Go 中，原子操作 是一种由标准库 sync/atomic 提供的高效、低开销的同步方式，用于在多 Goroutine 场景下安全地操作共享变量，而无需加锁。常见的原子操作有以下几类：

增减操作：对整数类型进行原子加减。
- atomic.AddInt32
- atomic.AddInt64
交换操作：将变量值设置为一个新值，并返回旧值。
- atomic.SwapInt32
- atomic.SwapInt64
- atomic.SwapPointer
比较并交换 (CAS)：只有在变量当前值与预期值相同时，才更新变量值。
- atomic.CompareAndSwapInt32
- atomic.CompareAndSwapInt64
- atomic.CompareAndSwapPointer
加载和存储操作：原子地读取或写入变量值。
- atomic.LoadInt32
- atomic.LoadInt64
- atomic.StoreInt32
- atomic.StoreInt64

这些操作对基础数据类型（如 int32, int64, uintptr, unsafe.Pointer）提供原子性支持，避免了数据竞争。

详细讲解与拓展

1. 增减操作

原子增减用于在多 Goroutine 场景下安全地对整数类型变量进行加减操作。

示例：

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var counter int32 = 0
    atomic.AddInt32(&counter, 1) // 原子加
    fmt.Println("Counter after increment:", counter)

    atomic.AddInt32(&counter, -1) // 原子减
    fmt.Println("Counter after decrement:", counter)
}

特性：
– 避免数据竞争，多个 Goroutine 可以同时对 counter 操作。
– 性能比使用锁（如 sync.Mutex）更高。

2. 交换操作

交换操作会将变量值设置为一个新值，并返回原值。

示例：

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var value int32 = 42
    oldValue := atomic.SwapInt32(&value, 100) // 原子交换
    fmt.Println("Old Value:", oldValue)
    fmt.Println("New Value:", value)
}

用途：
– 常用于实现轻量级的状态切换逻辑。
– 如单次初始化标志（flag）的切换。

3. 比较并交换 (CAS)

CAS 是一种重要的原子操作，用于条件更新变量。只有当变量的当前值等于预期值时，才能将变量更新为新值。

示例：

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var value int32 = 42
    swapped := atomic.CompareAndSwapInt32(&value, 42, 100) // 只有当 value == 42 时才会更新
    fmt.Println("Swapped:", swapped)
    fmt.Println("Value:", value)
}

用途：
– 实现无锁并发数据结构。
– 保证对共享数据的条件更新。

4. 加载和存储操作

这些操作用于原子地加载或存储变量值。

示例：

package main

import (
    "fmt"
    "sync/atomic"
)

func main() {
    var value int64 = 42

    atomic.StoreInt64(&value, 100) // 原子存储
    fmt.Println("Stored Value:", value)

    loadedValue := atomic.LoadInt64(&value) // 原子加载
    fmt.Println("Loaded Value:", loadedValue)
}

用途：
– 在多 Goroutine 场景下安全地读取和写入变量值。
– 常用于标志位、计数器的管理。

5. 结合 `unsafe.Pointer` 的原子操作

atomic 提供了对 unsafe.Pointer 的支持，可以原子地操作指针值。

示例：

package main

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

func main() {
    var ptr unsafe.Pointer
    str := "Hello"
    atomic.StorePointer(&ptr, unsafe.Pointer(&str)) // 原子存储指针

    loadedPtr := atomic.LoadPointer(&ptr) // 原子加载指针
    fmt.Println("Loaded Pointer Value:", *(*string)(loadedPtr))
}

用途：
– 操作复杂的数据结构指针，例如无锁队列或哈希表。

使用原子操作的优点和注意事项

优点：
1. 避免使用锁的性能开销，提高并发性能。
2. 代码简单，不需要手动管理锁的生命周期。

注意事项：
1. 原子操作仅适用于基础数据类型，复杂逻辑可能需要使用锁。
2. 使用 atomic 的变量必须是 32-bit 或 64-bit 对齐，否则可能导致未定义行为。
3. 操作多个共享变量时，仍可能需要锁以保证一致性。

总结

Go 原子操作（sync/atomic）提供了一组高效的同步工具，主要包括以下几类：
1. 增减操作：AddInt32，AddInt64。
2. 交换操作：SwapInt32，SwapInt64。
3. 比较并交换 (CAS)：CompareAndSwapInt32，CompareAndSwapInt64。
4. 加载和存储：LoadInt32，StoreInt32。
5. 指针操作：LoadPointer，StorePointer。

它们可以用来在多 Goroutine 场景下高效、安全地管理共享数据，避免数据竞争，同时减少锁的使用，但需要注意适用范围和对齐要求。