Golang如何实现并发安全的数据访问 对比Mutex与RWMutex性能差异

package main

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

// 示例：使用Mutex保护一个计数器
type SafeCounter struct {
    mu    sync.Mutex
    count int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock() // 确保锁在函数退出时被释放
    c.count++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

// 另一个例子：使用Mutex保护一个Map
type SafeMap struct {
    mu   sync.Mutex
    data map[string]string
}

func (sm *SafeMap) Set(key, value string) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMap) Get(key string) (string, bool) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    val, ok := sm.data[key]
    return val, ok
}

func main() {
    // 计数器示例
    counter := SafeCounter{}
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Inc()
        }()
    }
    wg.Wait()
    fmt.Printf("最终计数器的值: %d\n", counter.Value()) // 预期输出 1000

    // Map示例
    safeMap := SafeMap{data: make(map[string]string)}
    var wg2 sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg2.Add(1)
        go func(i int) {
            defer wg2.Done()
            key := fmt.Sprintf("key%d", i)
            value := fmt.Sprintf("value%d", i)
            safeMap.Set(key, value)
        }(i)
    }
    wg2.Wait()
    fmt.Printf("Map中元素数量: %d\n", len(safeMap.data)) // 预期输出 100
    fmt.Printf("获取key50的值: %s\n", safeMap.Get("key50"))
}

package main

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

// 示例：使用RWMutex保护一个缓存
type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

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

// Get方法获取读锁，允许多个并发读
func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock() // 获取读锁
    defer c.mu.RUnlock() // 释放读锁
    val, ok := c.data[key]
    return val, ok
}

// Set方法获取写锁，独占访问
func (c *Cache) Set(key, value string) {
    c.mu.Lock() // 获取写锁
    defer c.mu.Unlock() // 释放写锁
    c.data[key] = value
}

// Delete方法获取写锁
func (c *Cache) Delete(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.data, key)
}

func main() {
    cache := NewCache()
    var wg sync.WaitGroup

    // 写入一些初始数据
    cache.Set("name", "GoLang")
    cache.Set("version", "1.22")

    // 模拟大量并发读取
    for i := 0; i < 500; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            _, _ = cache.Get("name")
            _, _ = cache.Get("version")
            // 模拟一些计算
            time.Sleep(time.Millisecond * 1)
        }()
    }

    // 模拟少量并发写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("new_key_%d", i)
            value := fmt.Sprintf("new_value_%d", i)
            cache.Set(key, value)
            time.Sleep(time.Millisecond * 10) // 写入操作可能耗时更长
        }(i)
    }

    wg.Wait()
    fmt.Printf("缓存中name的值: %s\n", cache.Get("name"))
    fmt.Printf("缓存中new_key_3的值: %s\n", cache.Get("new_key_3"))
    fmt.Printf("最终缓存大小: %d\n", len(cache.data))
}

// 伪代码，实际测试会更复杂，包含读写操作的比例控制
// func BenchmarkMutexRead(b *testing.B) { ... }
// func BenchmarkMutexWrite(b *testing.B) { ... }
// func BenchmarkRWMutexRead(b *testing.B) { ... }
// func BenchmarkRWMutexWrite(b *testing.B) { ... }

// 当读操作占绝大部分时：
// BenchmarkRWMutexRead-8        100000000            10.5 ns/op   // 极快
// BenchmarkMutexRead-8            5000000           250.0 ns/op   // 慢很多

// 当写操作占大部分或读写均衡时：
// BenchmarkRWMutexWrite-8         1000000           1200.0 ns/op  // 可能与Mutex接近或略慢
// BenchmarkMutexWrite-8           1000000           1000.0 ns/op  // 相对稳定