Go 读写锁rwmutex

介绍[编辑 | 编辑源代码]

读写锁（RWMutex）是Go语言标准库`sync`包中提供的一种同步机制，用于解决多线程环境下对共享资源的读写冲突问题。与普通的互斥锁（`Mutex`）不同，`RWMutex`允许多个读操作同时进行，但写操作是独占的。这种设计显著提高了读多写少场景下的并发性能。

核心特性[编辑 | 编辑源代码]

共享读锁（RLock）：多个协程可以同时持有读锁，互不阻塞。
独占写锁（Lock）：写锁被持有时，其他协程无法获取读锁或写锁。
优先级规则：写锁优先于读锁，避免写操作被无限延迟（写者饥饿问题）。

基本用法[编辑 | 编辑源代码]

以下是`RWMutex`的常用方法：

`func (rw *RWMutex) RLock()`：获取读锁。
`func (rw *RWMutex) RUnlock()`：释放读锁。
`func (rw *RWMutex) Lock()`：获取写锁。
`func (rw *RWMutex) Unlock()`：释放写锁。

代码示例[编辑 | 编辑源代码]

  
package main  

import (  
    "fmt"  
    "sync"  
    "time"  
)  

var (  
    counter int  
    rwMutex sync.RWMutex  
)  

func readValue(id int) {  
    rwMutex.RLock()  
    defer rwMutex.RUnlock()  
    fmt.Printf("Reader %d: Counter = %d\n", id, counter)  
}  

func writeValue() {  
    rwMutex.Lock()  
    defer rwMutex.Unlock()  
    counter++  
    fmt.Printf("Writer: Incremented counter to %d\n", counter)  
}  

func main() {  
    for i := 1; i <= 3; i++ {  
        go readValue(i)  
    }  
    go writeValue()  
    time.Sleep(1 * time.Second)  
}

输出示例（可能因调度顺序不同）：

  
Reader 1: Counter = 0  
Reader 3: Counter = 0  
Reader 2: Counter = 0  
Writer: Incremented counter to 1

解释： 1. 三个读协程可以同时访问`counter`，因为`RLock()`允许多个读操作。 2. 写协程会阻塞直到所有读锁释放，确保数据一致性。

实际应用场景[编辑 | 编辑源代码]

缓存系统[编辑 | 编辑源代码]

在缓存系统中，频繁读取但较少更新的场景（如配置缓存）适合使用`RWMutex`：

  
type Cache struct {  
    data map[string]string  
    rwMutex sync.RWMutex  
}  

func (c *Cache) Get(key string) string {  
    c.rwMutex.RLock()  
    defer c.rwMutex.RUnlock()  
    return c.data[key]  
}  

func (c *Cache) Set(key, value string) {  
    c.rwMutex.Lock()  
    defer c.rwMutex.Unlock()  
    c.data[key] = value  
}