Go语言中并发迭代Map的线程安全性与同步策略

package main

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

// SafeMap 是一个并发安全的 map 结构
type SafeMap struct {
    mu sync.RWMutex
    m  map[string]interface{}
}

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

// Write 安全地向 map 中写入键值对
func (sm *SafeMap) Write(key string, value interface{}) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保写锁被释放
    sm.m[key] = value
    fmt.Printf("写入: %s = %v\n", key, value)
}

// Read 安全地从 map 中读取值
func (sm *SafeMap) Read(key string) (interface{}, bool) {
    sm.mu.RLock() // 获取读锁
    defer sm.mu.RUnlock() // 确保读锁被释放
    val, ok := sm.m[key]
    fmt.Printf("读取: %s = %v (存在: %t)\n", key, val, ok)
    return val, ok
}

// Delete 安全地从 map 中删除键值对
func (sm *SafeMap) Delete(key string) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保写锁被释放
    delete(sm.m, key)
    fmt.Printf("删除: %s\n", key)
}

// IterateAndProcess 安全地迭代 map 并处理每个元素
func (sm *SafeMap) IterateAndProcess() {
    sm.mu.RLock() // 在迭代前获取读锁，阻塞所有写操作
    defer sm.mu.RUnlock() // 迭代完成后释放读锁

    fmt.Println("开始安全迭代:")
    for k, v := range sm.m {
        // 在这里处理 k, v
        // 此时，map的写操作被阻塞，读操作可以并发进行
        // 但如果 v 是一个引用类型，其内部状态的并发访问仍需单独同步
        fmt.Printf("  迭代中: %s = %v\n", k, v)
        time.Sleep(50 * time.Millisecond) // 模拟处理时间
    }
    fmt.Println("迭代结束.")
}

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

    // 启动多个 goroutine 进行并发写入
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", id)
            value := fmt.Sprintf("value%d", id)
            safeMap.Write(key, value)
        }(i)
    }

    // 启动多个 goroutine 进行并发读取
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key%d", id%3) // 尝试读取已存在和不存在的键
            safeMap.Read(key)
        }(i)
    }

    // 启动一个 goroutine 进行迭代
    wg.Add(1)
    go func() {
        defer wg.Done()
        time.Sleep(100 * time.Millisecond) // 等待一些写入完成
        safeMap.IterateAndProcess()
    }()

    // 启动一个 goroutine 进行删除
    wg.Add(1)
    go func() {
        defer wg.Done()
        time.Sleep(200 * time.Millisecond) // 等待一些操作完成
        safeMap.Delete("key1")
    }()

    wg.Wait()
    fmt.Println("所有操作完成。")
}

package main

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

var protectedMap = make(map[string]interface{})
var mapAccess = make(chan struct{}, 1) // 容量为1的缓冲channel作为令牌

func init() {
    mapAccess <- struct{}{} // 初始化时放入一个令牌，表示资源可用
}

// SafeWriteWithChannel 通过 channel 令牌安全地写入 map
func SafeWriteWithChannel(key string, value interface{}) {
    <-mapAccess // 获取令牌，阻塞直到令牌可用
    defer func() {
        mapAccess <- struct{}{} // 释放令牌
    }()
    protectedMap[key] = value
    fmt.Printf("Channel写入: %s = %v\n", key, value)
}

// SafeReadWithChannel 通过 channel 令牌安全地读取 map
func SafeReadWithChannel(key string) (interface{}, bool) {
    <-mapAccess // 获取令牌
    defer func() {
        mapAccess <- struct{}{} // 释放令牌
    }()
    val, ok := protectedMap[key]
    fmt.Printf("Channel读取: %s = %v (存在: %t)\n", key, val, ok)
    return val, ok
}

// SafeIterateWithChannel 通过 channel 令牌安全地迭代 map
func SafeIterateWithChannel() {
    <-mapAccess // 获取令牌
    defer func() {
        mapAccess <- struct{}{} // 释放令牌
    }()
    fmt.Println("开始Channel迭代:")
    for k, v := range protectedMap {
        fmt.Printf("  Channel迭代中: %s = %v\n", k, v)
        time.Sleep(30 * time.Millisecond) // 模拟处理时间
    }
    fmt.Println("Channel迭代结束.")
}

func main() {
    var wg sync.WaitGroup

    // 模拟并发操作
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            SafeWriteWithChannel(fmt.Sprintf("chanKey%d", id), fmt.Sprintf("chanValue%d", id))
            SafeReadWithChannel(fmt.Sprintf("chanKey%d", id))
        }(i)
    }

    wg.Add(1)
    go func() {
        defer wg.Done()
        time.Sleep(50 * time.Millisecond) // 等待一些写入
        SafeIterateWithChannel()
    }()

    wg.Wait()
    fmt.Println("所有Channel操作完成。")
}