Go 原子操作和信号量：低级别并发控制

后端

2023-09-13 11:54:53

原子操作和信号量：Go 中的并发控制基石

在并发编程的世界中，管理共享内存资源的访问和修改至关重要。Go 语言为我们提供了原子操作和信号量这两种机制，它们为实现这一点提供了强大的工具。

原子操作：保证内存更新的完整性

原子操作就像并发编程中的交通警察，确保对内存位置的更新以不可分割的方式进行。即使有多个协程同时访问同一内存位置，原子操作也能保证更新的顺序一致性。Go 中支持的主要原子操作包括：

比较并交换 (CAS) ：检查内存位置的值是否与预期值相等，如果是则进行交换操作。
加载和存储 ：以原子方式从内存位置加载或存储值。
增量和递减 ：以原子方式对内存位置中的值进行增减操作。

使用原子操作可以避免数据竞争（data race）和内存损坏，确保共享内存资源的更新是可靠和可预测的。

信号量：限制并发访问

信号量就像通往共享资源的闸门，它控制着并发访问的数量。本质上，它是一个计数器，表示资源的可用数量。协程在访问资源之前会尝试获取信号量。如果信号量可用，协程将继续执行；如果不可用，协程将阻塞，直到信号量再次可用。

信号量通常用于：

限制对共享资源的并发访问数量，防止过度使用和资源饥饿。
实现生产者-消费者模式，协调协程之间的数据交换。

Go 中的原子操作和信号量

Go 提供了内置的包和函数来使用原子操作和信号量：

sync/atomic 包提供了原子操作函数，如 CompareAndSwapInt32 和 AddInt64。
sync 包提供了信号量类型 Semaphore，可以用来限制对共享资源的并发访问。

示例：使用原子操作实现互斥锁

import (
    "sync/atomic"
    "time"
)

type Mutex struct {
    locked int32
}

func (m *Mutex) Lock() {
    for !atomic.CompareAndSwapInt32(&m.locked, 0, 1) {
        time.Sleep(100 * time.Microsecond)
    }
}

func (m *Mutex) Unlock() {
    atomic.StoreInt32(&m.locked, 0)
}

示例：使用信号量限制并发访问

import (
    "sync"
    "fmt"
)

var semaphore = sync.Semaphore{Max: 5}

func main() {
    for i := 0; i < 10; i++ {
        go func(i int) {
            semaphore.Acquire(ctx)
            fmt.Printf("Goroutine %d acquired semaphore\n", i)
            time.Sleep(1 * time.Second)
            semaphore.Release(ctx)
        }(i)
    }
    time.Sleep(10 * time.Second)
}