Go语言并发Map访问：读写安全与同步机制详解

package main

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

func main() {
    m := make(map[int]int)
    wg := sync.WaitGroup{}

    // 启动多个goroutine进行写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                m[id*100+j] = id // 写入操作
            }
        }(i)
    }

    // 启动一个goroutine进行读取（即使是读，在有写并发时也可能出问题）
    wg.Add(1)
    go func() {
        defer wg.Done()
        for k := 0; k < 100; k++ {
            // 尝试读取，在有写入并发时可能读取到不一致数据或panic
            _ = m[k]
            time.Sleep(time.Millisecond) // 模拟读取耗时
        }
    }()

    wg.Wait()
    fmt.Println("Map size:", len(m))
}

package main

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

// SafeMap 结构体，包含一个map和一个互斥锁
type SafeMap struct {
    mu sync.Mutex
    m  map[int]int
}

// NewSafeMap 创建并返回一个新的SafeMap
func NewSafeMap() *SafeMap {
    return &SafeMap{
        m: make(map[int]int),
    }
}

// Set 方法安全地写入map
func (sm *SafeMap) Set(key, value int) {
    sm.mu.Lock()   // 加锁
    defer sm.mu.Unlock() // 解锁
    sm.m[key] = value
}

// Get 方法安全地读取map
func (sm *SafeMap) Get(key int) (int, bool) {
    sm.mu.Lock()   // 加锁
    defer sm.mu.Unlock() // 解锁
    val, ok := sm.m[key]
    return val, ok
}

// Len 方法安全地获取map长度
func (sm *SafeMap) Len() int {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    return len(sm.m)
}

func main() {
    safeMap := NewSafeMap()
    wg := sync.WaitGroup{}

    // 启动多个goroutine进行写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                safeMap.Set(id*100+j, id) // 安全写入
            }
        }(i)
    }

    // 启动一个goroutine进行读取
    wg.Add(1)
    go func() {
        defer wg.Done()
        for k := 0; k < 100; k++ {
            val, ok := safeMap.Get(k) // 安全读取
            if ok {
                // fmt.Printf("Read key %d: %d\n", k, val)
            }
            time.Sleep(time.Millisecond) // 模拟读取耗时
        }
    }()

    wg.Wait()
    fmt.Println("SafeMap size:", safeMap.Len()) // 安全获取长度
}

package main

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

type RWSafeMap struct {
    mu sync.RWMutex
    m  map[int]int
}

func NewRWSafeMap() *RWSafeMap {
    return &RWSafeMap{
        m: make(map[int]int),
    }
}

// Set 方法使用写锁保护写入操作
func (sm *RWSafeMap) Set(key, value int) {
    sm.mu.Lock()   // 获取写锁
    defer sm.mu.Unlock() // 释放写锁
    sm.m[key] = value
}

// Get 方法使用读锁保护读取操作
func (sm *RWSafeMap) Get(key int) (int, bool) {
    sm.mu.RLock()   // 获取读锁
    defer sm.mu.RUnlock() // 释放读锁
    val, ok := sm.m[key]
    return val, ok
}

// Len 方法使用读锁保护读取操作
func (sm *RWSafeMap) Len() int {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    return len(sm.m)
}

func main() {
    rwSafeMap := NewRWSafeMap()
    wg := sync.WaitGroup{}

    // 启动多个goroutine进行写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 100; j++ {
                rwSafeMap.Set(id*100+j, id)
            }
        }(i)
    }

    // 启动大量goroutine进行读取
    for i := 0; i < 10; i++ { // 更多读者
        wg.Add(1)
        go func(readerID int) {
            defer wg.Done()
            for k := 0; k < 100; k++ {
                val, ok := rwSafeMap.Get(k)
                if ok {
                    // fmt.Printf("Reader %d: Read key %d: %d\n", readerID, k, val)
                }
                time.Sleep(time.Millisecond / 2) // 模拟读取耗时，比写入快
            }
        }(i)
    }

    wg.Wait()
    fmt.Println("RWSafeMap size:", rwSafeMap.Len())
}