Golang原子操作何时该用Load和Store

atomic.Load和atomic.Store用于多goroutine下安全读写共享变量，避免锁开销；适用于简单读写场景，如标志位或计数器，而复杂操作仍需互斥锁。

在Golang并发编程中，atomic.Load和atomic.Store用于在多个goroutine之间安全地读取和写入共享变量，而无需使用互斥锁。当你需要以最高效的方式读取或修改一个变量，并且不希望引入互斥锁带来的性能开销时，它们就派上用场了。当然，前提是你的操作足够简单，仅仅是读取或写入。

原子操作适用于对单个变量的读写操作，保证这些操作的原子性，即不可中断性。

为什么不用互斥锁？

互斥锁（sync.Mutex）虽然可以保护共享资源，但在高并发场景下，锁的竞争会导致性能下降。atomic.Load和atomic.Store提供了一种更轻量级的同步机制，它们通常基于CPU的原子指令实现，避免了上下文切换和锁的开销。但是，原子操作只适用于简单的读写，对于更复杂的操作，互斥锁仍然是必要的。

何时使用atomic.Load？

当你需要读取一个共享变量的值，并且不希望在读取期间有其他goroutine修改它时，使用atomic.Load。例如，一个标志位，用于指示程序是否应该停止运行。

package main

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

var running int32 = 1

func main() {
    go func() {
        for {
            if atomic.LoadInt32(&running) == 0 {
                fmt.Println("Stopping worker...")
                return
            }
            fmt.Println("Worker running...")
            time.Sleep(time.Millisecond * 500)
        }
    }()

    time.Sleep(time.Second * 3)
    fmt.Println("Stopping program...")
    atomic.StoreInt32(&running, 0)
    time.Sleep(time.Second)
    fmt.Println("Program stopped.")
}

在这个例子中，atomic.LoadInt32(&running)确保了worker goroutine读取到的running变量的值是最新的，避免了数据竞争。

何时使用atomic.Store？

当你需要更新一个共享变量的值，并且希望保证更新操作的原子性，防止出现中间状态时，使用atomic.Store。比如，更新一个配置项，或者设置一个状态标志。

package main

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

var counter int64

func main() {
    for i := 0; i < 1000; i++ {
        go func() {
            for j := 0; j < 1000; j++ {
                atomic.AddInt64(&counter, 1) // 使用atomic.AddInt64更简洁
            }
        }()
    }

    time.Sleep(time.Second * 2)
    fmt.Println("Counter:", atomic.LoadInt64(&counter))
}

这里，atomic.AddInt64(&counter, 1)保证了对counter变量的递增操作是原子的，避免了多个goroutine同时修改counter导致的数据丢失。

atomic.Value的使用场景

atomic.Value 允许你原子地存储和加载任意类型的值。它特别适用于需要原子地替换整个对象，而不是简单地读写基本类型。例如，动态更新配置对象。

package main

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

type Config struct {
    Value string
}

var config atomic.Value

func main() {
    // 初始配置
    initialConfig := Config{Value: "Initial Value"}
    config.Store(initialConfig)

    // 定期更新配置
    go func() {
        for i := 0; i < 5; i++ {
            newConfig := Config{Value: fmt.Sprintf("Value %d", i)}
            config.Store(newConfig)
            fmt.Println("Updated config:", newConfig)
            time.Sleep(time.Millisecond * 500)
        }
    }()

    // 读取配置
    for i := 0; i < 10; i++ {
        currentConfig := config.Load().(Config)
        fmt.Println("Current config:", currentConfig)
        time.Sleep(time.Millisecond * 200)
    }
}

在这个例子中，atomic.Value 存储了 Config 对象，并允许我们原子地替换整个配置对象，保证在任何时候读取到的配置都是一个完整的、一致的对象。

如何选择合适的原子操作函数？

atomic 包提供了多种原子操作函数，适用于不同的数据类型。例如，atomic.LoadInt32、atomic.StoreInt64、atomic.AddUint64 等。选择合适的函数取决于你要操作的数据类型。此外，atomic.CompareAndSwap 函数允许你原子地比较并交换变量的值，这对于实现一些复杂的同步逻辑非常有用。

原子操作的性能考量

虽然原子操作比互斥锁更轻量级，但它们仍然有一定的性能开销。在高并发、对性能要求非常苛刻的场景下，需要仔细评估原子操作带来的性能影响。在某些情况下，使用更复杂的并发模式，例如 channel，可能可以获得更好的性能。但channel会增加代码的复杂性。

原子操作的局限性

原子操作只能保证单个变量的读写操作是原子的。对于需要原子地执行多个操作的场景，原子操作就无能为力了。这时，仍然需要使用互斥锁或者其他更高级的同步机制。例如，一个银行转账操作，需要同时更新两个账户的余额，这时就需要使用事务或者互斥锁来保证操作的原子性。