悲观锁、乐观锁、无锁：Go 并发控制的三种姿势

// 扣减库存
if stock > 0 {
    stock--
}

package main

import (
    "fmt"
    "sync"
)

var (
    stock int = 100
    mu    sync.Mutex
)

func deduct() {
    mu.Lock()         // 加锁
    defer mu.Unlock() // 确保释放锁

    if stock > 0 {
        stock--
    }
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 200; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            deduct()
        }()
    }

    wg.Wait()
    fmt.Println("Final stock:", stock) // 输出: Final stock: 0
}

var (
    data map[string]string
    rwmu sync.RWMutex
)

// 读操作：可以多个 goroutine 同时读
func get(key string) string {
    rwmu.RLock()
    defer rwmu.RUnlock()
    return data[key]
}

// 写操作：独占锁
func set(key, value string) {
    rwmu.Lock()
    defer rwmu.Unlock()
    data[key] = value
}

package main

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

var stock int64 = 100

func deductCAS() bool {
    for {
        old := atomic.LoadInt64(&stock)
        if old <= 0 {
            return false // 库存不足
        }

        // CAS：如果 stock 还是 old，就减 1
        if atomic.CompareAndSwapInt64(&stock, old, old-1) {
            return true // 扣减成功
        }
        // 如果失败（说明被别人改了），自动重试
    }
}

func main() {
    var wg sync.WaitGroup
    successCount := int64(0)

    for i := 0; i < 200; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            if deductCAS() {
                atomic.AddInt64(&successCount, 1)
            }
        }()
    }

    wg.Wait()
    fmt.Println("Final stock:", stock)         // 输出: 0
    fmt.Println("Success count:", successCount) // 输出: 100
}

// 原子加减
atomic.AddInt64(&counter, 1)   // counter++
atomic.AddInt64(&counter, -1)  // counter--

// 原子读写
val := atomic.LoadInt64(&counter)
atomic.StoreInt64(&counter, 100)

// CAS
swapped := atomic.CompareAndSwapInt64(&counter, oldVal, newVal)

type Item struct {
    ID      int
    Stock   int
    Version int // 版本号
}

func deductWithVersion(item *Item) error {
    // 1. 读取当前数据
    oldVersion := item.Version

    // 2. 业务逻辑
    if item.Stock <= 0 {
        return errors.New("insufficient stock")
    }
    item.Stock--

    // 3. 带版本号更新（伪代码，实际是 SQL）
    // UPDATE items SET stock = ?, version = version + 1 
    // WHERE id = ? AND version = ?
    affected := db.Update(item, oldVersion)

    if affected == 0 {
        return errors.New("concurrent modification, retry")
    }
    return nil
}

时间线：
goroutine 1: 读到 stock = 100
goroutine 2: stock 100 -> 99 -> 100（被别人扣了又加回来）
goroutine 1: CAS(100, 99) 成功（但其实中间发生过变化）

package main

import (
    "fmt"
)

// 库存管理器（单一 goroutine 持有状态）
func stockManager(stock int, requests <-chan chan bool) {
    for req := range requests {
        if stock > 0 {
            stock--
            req <- true  // 扣减成功
        } else {
            req <- false // 库存不足
        }
    }
}

func main() {
    requests := make(chan chan bool)

    // 启动库存管理器
    go stockManager(100, requests)

    // 模拟 200 个并发请求
    done := make(chan bool, 200)
    successCount := 0

    for i := 0; i < 200; i++ {
        go func() {
            reply := make(chan bool)
            requests <- reply   // 发送请求
            success := <-reply  // 等待响应
            done <- success
        }()
    }

    // 统计结果
    for i := 0; i < 200; i++ {
        if <-done {
            successCount++
        }
    }

    fmt.Println("Success count:", successCount) // 输出: 100
}

type Config struct {
    DBHost   string
    DBPort   int
    LogLevel string
}

var currentConfig atomic.Value // 存储 *Config

func init() {
    currentConfig.Store(&Config{
        DBHost:   "localhost",
        DBPort:   5432,
        LogLevel: "info",
    })
}

// 读取配置（无锁）
func GetConfig() *Config {
    return currentConfig.Load().(*Config)
}

// 更新配置（创建新对象，原子替换）
func UpdateConfig(newHost string) {
    old := GetConfig()
    newConfig := &Config{
        DBHost:   newHost,
        DBPort:   old.DBPort,
        LogLevel: old.LogLevel,
    }
    currentConfig.Store(newConfig)
}

const shardCount = 16

type ShardedCounter struct {
    shards [shardCount]struct {
        sync.Mutex
        count int64
    }
}

func (c *ShardedCounter) Inc(key string) {
    // 根据 key 哈希到某个分区
    shard := &c.shards[hash(key)%shardCount]
    shard.Lock()
    shard.count++
    shard.Unlock()
}

func (c *ShardedCounter) Total() int64 {
    var total int64
    for i := range c.shards {
        c.shards[i].Lock()
        total += c.shards[i].count
        c.shards[i].Unlock()
    }
    return total
}

问自己一个问题：写操作多还是少？

        写操作多？
          / \
         /   \
        是    否
       /        \
   悲观锁      冲突概率高？
               /  \
              /    \
             是    否
            /        \
       悲观锁      乐观锁/无锁

package main

import (
    "sync"
    "sync/atomic"
    "testing"
)

var (
    counterMutex int64
    mu           sync.Mutex
    counterAtomic int64
)

// 悲观锁
func BenchmarkMutex(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            mu.Lock()
            counterMutex++
            mu.Unlock()
        }
    })
}

// 乐观锁（atomic）
func BenchmarkAtomic(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            atomic.AddInt64(&counterAtomic, 1)
        }
    })
}

go test -bench=. -benchmem -cpu=1,4,8

@startmindmap
* 并发控制三种姿势
** 悲观锁
*** 先锁后干活
*** sync.Mutex
*** sync.RWMutex
*** 写多竞争激烈
** 乐观锁
*** 先干活后检查
*** CAS 实现
*** 版本号变体
*** ABA 问题
*** 读多写少
** 无锁
*** 避免共享状态
*** Channel CSP
*** 不可变数据
*** 分区 Sharding
** 选择建议
*** 写多用悲观锁
*** 读多用乐观/无锁
*** Benchmark 验证
@endmindmap