Go语言并发编程临界区的使用

var counter int // 共享变量

func increment() {
    counter++ // 这就是临界区（没有保护）
}

var (
    counter int
    mu      sync.Mutex
)

func safeIncrement() {
    mu.Lock()         // 进入临界区前加锁
    defer mu.Unlock() // 确保退出时解锁
    
    counter++         // 受保护的临界区
    // 其他操作...
}

   // 不好：包含非必要操作
   mu.Lock()
   data := fetchFromDatabase() // 耗时IO操作
   sharedMap[key] = data
   mu.Unlock()
   
   // 更好：仅保护共享访问
   data := fetchFromDatabase()
   mu.Lock()
   sharedMap[key] = data
   mu.Unlock()

var mu sync.Mutex

func accessShared() {
    mu.Lock()
    // 临界区...
    mu.Unlock()
}

var rwMu sync.RWMutex

func readShared() {
    rwMu.RLock()
    // 只读临界区（允许多个读者）
    rwMu.RUnlock()
}

func writeShared() {
    rwMu.Lock()
    // 写临界区（独占）
    rwMu.Unlock()
}

var ch = make(chan struct{}, 1) // 容量1的通道模拟锁

func accessShared() {
    ch <- struct{}{} // 获取"锁"
    // 临界区...
    <-ch // 释放"锁"
}

// 两个goroutine并发执行此函数会导致数据竞争
func race() {
    counter++ // 未保护的临界区
}

func deadlock() {
    mu.Lock()
    mu.Lock() // 重复加锁导致死锁
    mu.Unlock()
    mu.Unlock()
}

// 两个goroutine不断重试但无法进展
func livelock() {
    for {
        if mu.TryLock() { // Go 1.18+
            // 临界区...
            mu.Unlock()
            break
        }
        time.Sleep(time.Millisecond) // 可能导致活锁
    }
}

type Account struct {
    mu      sync.Mutex
    balance int
}

func (a *Account) Transfer(to *Account, amount int) error {
    // 按固定顺序加锁防止死锁
    first, second := a, to
    if a < to { // 通过地址比较确定顺序
        first, second = to, a
    }
    
    first.mu.Lock()
    defer first.mu.Unlock()
    second.mu.Lock()
    defer second.mu.Unlock()
    
    // 临界区开始
    if a.balance < amount {
        return errors.New("insufficient balance")
    }
    a.balance -= amount
    to.balance += amount
    // 临界区结束
    
    return nil
}