Golang基础-读写锁及应用场景_golang sync.rwmutex-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_38609643/article/details/144962855

Go 中的读写锁（`sync.RWMutex`）介绍

Go 提供的读写锁（sync.RWMutex）是一种允许多个 读操作并发，但 写操作互斥 的锁。它主要解决了以下问题：当一个共享资源被多个 goroutine 读取时，如何提高并发性；同时，当有写操作时，如何保证写操作的独占性和安全性。

sync.RWMutex 是 Go 的 sync.Mutex 的一种扩展，提供了两种操作：

读锁（RLock()）：
- 允许多个 goroutine 同时持有读锁。
- 适用于并发读操作的场景，当多个 goroutine 只需要读取数据时，可以同时获取锁，避免了每个读取都需要阻塞其他读取操作。
写锁（Lock()）：
- 只允许一个 goroutine 持有写锁。
- 写操作是独占的，在写操作进行时，所有其他的读操作和写操作都会被阻塞，直到写锁释放。

`sync.RWMutex` 的基本用法

package main

import (
    "fmt"
    "sync"
)

var (
    rwLock sync.RWMutex
    data   int
)

func readData() {
    rwLock.RLock() // 获取读锁
    defer rwLock.RUnlock() // 释放读锁
    fmt.Println("Read data:", data)
}

func writeData(val int) {
    rwLock.Lock() // 获取写锁
    defer rwLock.Unlock() // 释放写锁
    data = val
    fmt.Println("Data written:", val)
}

func main() {
    // 启动多个读 goroutine
    for i := 0; i < 5; i++ {
        go readData()
    }
    
    // 启动一个写 goroutine
    go writeData(42)

    // 等待 goroutine 完成
    var wg sync.WaitGroup
    wg.Add(6)
    for i := 0; i < 5; i++ {
        go func() {
            defer wg.Done()
            readData()
        }()
    }
    go func() {
        defer wg.Done()
        writeData(100)
    }()
    wg.Wait()
}

`sync.RWMutex` 的操作

RLock() 和 RUnlock()：用于加读锁和释放读锁。当一个 goroutine 获取读锁后，其他 goroutine 也可以同时获取读锁（只要没有写锁存在）。当读锁释放时，其他 goroutine 才能获取写锁。
Lock() 和 Unlock()：用于加写锁和释放写锁。当一个 goroutine 获取写锁时，所有读操作和写操作都会被阻塞，直到写锁被释放。

读写锁的应用场景

sync.RWMutex 主要适用于以下场景：

1. 多读少写的场景

读写锁的优势体现在当读操作远多于写操作的情况下。多个 goroutine 可以同时读取共享数据，只要没有写操作进行。
比如：缓存系统、配置管理、数据库查询等场景中，数据的读取远远多于修改。

示例：

一个网站的缓存系统中，很多 goroutine 需要读取缓存，而修改缓存的操作相对较少。此时可以通过读写锁来保证并发读取，同时保证写入时数据的安全性。

2. 频繁的并发读取

如果共享数据被频繁地读取，并且读操作比写操作多得多，那么使用读写锁比使用普通的互斥锁（sync.Mutex）更有效。通过读锁，可以实现更高的并发度。

3. 避免写锁竞争

写锁竞争是导致性能瓶颈的一个常见原因。如果每次都要使用普通的互斥锁（sync.Mutex），当有一个写操作时，所有的读操作都会被阻塞。通过读写锁，可以让多个 goroutine 在读取时并发进行，从而提高系统的吞吐量。

示例：读写锁在缓存系统中的应用

假设你实现一个简单的缓存系统：

package main

import (
    "fmt"
    "sync"
)

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

func NewCache() *Cache {
    return &Cache{
        data: make(map[string]string),
    }
}

func (c *Cache) Get(key string) string {
    c.rwLock.RLock() // 获取读锁
    defer c.rwLock.RUnlock() // 释放读锁
    return c.data[key]
}

func (c *Cache) Set(key, value string) {
    c.rwLock.Lock() // 获取写锁
    defer c.rwLock.Unlock() // 释放写锁
    c.data[key] = value
}

func main() {
    cache := NewCache()

    // 多个 goroutine 并发读取缓存
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("Read key%d: %s\n", i, cache.Get(fmt.Sprintf("key%d", i)))
        }(i)
    }

    // 单个 goroutine 写入缓存
    wg.Add(1)
    go func() {
        defer wg.Done()
        cache.Set("key1", "value1")
    }()

    wg.Wait()
}

在上面的代码中，多个 goroutine 同时读取缓存，而在缓存的写操作时使用写锁。这种做法保证了数据的安全性，并且在读取时允许多个 goroutine 并发访问，极大提高了系统的吞吐量。

读写锁的性能考量

读写锁带来的性能提升：
- 在读操作频繁的情况下，读写锁通过允许并发的读取操作，能够提高系统性能，减少阻塞。
写操作的阻塞性：
- 由于写操作是独占的，写锁的争用可能会成为瓶颈。如果在高并发的写操作场景中频繁获取写锁，可能会导致性能下降。
性能下降的原因：
- 如果写锁竞争激烈，或者写操作较为频繁，读写锁可能反而比普通的互斥锁 (sync.Mutex) 性能更差。
- 如果系统中只有少量的读操作和频繁的写操作，使用普通的互斥锁（sync.Mutex）可能会比读写锁更简单高效。