Go语言中Map并发迭代与读写安全：深度解析与实践

package main

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

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

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

// Store 设置键值对
func (sm *SafeMap) Store(key string, value interface{}) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保释放写锁
    sm.data[key] = value
}

// Load 获取键对应的值，如果不存在则返回nil和false
func (sm *SafeMap) Load(key string) (interface{}, bool) {
    sm.mu.RLock() // 获取读锁
    defer sm.mu.RUnlock() // 确保释放读锁
    val, ok := sm.data[key]
    return val, ok
}

// Delete 删除键值对
func (sm *SafeMap) Delete(key string) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保释放写锁
    delete(sm.data, key)
}

// RangeIter 迭代map中的所有元素，并对每个元素执行一个函数
// 注意：在整个迭代过程中持有读锁，可能影响并发写入性能
func (sm *SafeMap) RangeIter(f func(key string, value interface{})) {
    sm.mu.RLock() // 获取读锁
    defer sm.mu.RUnlock() // 确保释放读锁
    for k, v := range sm.data {
        f(k, v)
    }
}

func main() {
    safeMap := NewSafeMap()

    // 启动多个协程进行写入
    for i := 0; i < 5; i++ {
        go func(id int) {
            for j := 0; j < 10; j++ {
                key := fmt.Sprintf("key-%d-%d", id, j)
                value := fmt.Sprintf("value-%d-%d", id, j)
                safeMap.Store(key, value)
                time.Sleep(time.Millisecond * 10)
            }
        }(i)
    }

    // 启动多个协程进行读取
    for i := 0; i < 5; i++ {
        go func(id int) {
            for j := 0; j < 10; j++ {
                key := fmt.Sprintf("key-%d-%d", id, j)
                val, ok := safeMap.Load(key)
                if ok {
                    // fmt.Printf("Reader %d: Loaded %s = %v\n", id, key, val)
                } else {
                    // fmt.Printf("Reader %d: Key %s not found\n", id, key)
                }
                time.Sleep(time.Millisecond * 5)
            }
        }(i)
    }

    time.Sleep(time.Second * 2) // 等待所有协程完成

    fmt.Println("Final map content (using RangeIter):")
    safeMap.RangeIter(func(key string, value interface{}) {
        fmt.Printf("  %s: %v\n", key, value)
    })
    fmt.Printf("Total elements: %d\n", len(safeMap.data)) // 注意：直接访问len(sm.data)仍需加锁
}

// 假设有一个 SafeMap 实例 safeMap
// ...

// 迭代并安全地处理每个元素
func (sm *SafeMap) ProcessElementsSafely() {
    // 策略一：在整个迭代过程中持有读锁。
    // 优点：简单，确保迭代期间map内容稳定（对于读取）。
    // 缺点：如果迭代时间长，会阻塞所有写操作。
    sm.mu.RLock()
    defer sm.mu.RUnlock()

    for k, v := range sm.data {
        // 在这里处理 k 和 v，它们在获取读锁的时刻是稳定的。
        // fmt.Printf("Processing (full lock): %s -> %v\n", k, v)
        _ = k
        _ = v
    }

    // 策略二：仅在需要访问map元素时获取读锁。
    // 这种方法更细粒度，但需要注意键在获取到之后是否被删除。
    // 适用于不需要对整个map快照进行操作的场景。
    // 注意：这里的 for k := range sm.data 仍然是在没有锁的情况下获取键的迭代器，
    // 但Go的range机制保证了迭代器本身的稳定性。
    // 关键在于对 map[k] 的访问必须在锁的保护下。
    for k := range sm.data { // 迭代器本身是稳定的
        sm.mu.RLock() // 对当前键 k 获取读锁
        v, found := sm.data[k] // 在读锁保护下获取值
        sm.mu.RUnlock() // 释放读锁

        if found {
            // fmt.Printf("Processing (per-key lock): %s -> %v\n", k, v)
            _ = k
            _ = v
        }
    }
}

package main

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

func main() {
    var sm sync.Map

    // 启动多个协程进行写入
    for i := 0; i < 5; i++ {
        go func(id int) {
            for j := 0; j < 10; j++ {
                key := fmt.Sprintf("syncmap-key-%d-%d", id, j)
                value := fmt.Sprintf("syncmap-value-%d-%d", id, j)
                sm.Store(key, value)
                time.Sleep(time.Millisecond * 10)
            }
        }(i)
    }

    // 启动多个协程进行读取
    for i := 0; i < 5; i++ {
        go func(id int) {
            for j := 0; j < 10; j++ {
                key := fmt.Sprintf("syncmap-key-%d-%d", id, j)
                val, ok := sm.Load(key)
                if ok {
                    // fmt.Printf("SyncMap Reader %d: Loaded %s = %v\n", id, key, val)
                }
                time.Sleep(time.Millisecond * 5)
            }
        }(i)
    }

    time.Sleep(time.Second * 2) // 等待所有协程完成

    fmt.Println("Final sync.Map content (using Range):")
    count := 0
    sm.Range(func(key, value interface{}) bool {
        fmt.Printf("  %v: %v\n", key, value)
        count++
        return true // 返回true继续迭代，返回false停止迭代
    })
    fmt.Printf("Total elements in sync.Map: %d\n", count)
}

// 概念性示例：使用Channel作为独占访问令牌
package main

import (
    "fmt"
    "time"
)

type TokenSafeMap struct {
    data map[string]interface{}
    token chan struct{} // 容量为1的channel作为令牌
}

func NewTokenSafeMap() *TokenSafeMap {
    return &TokenSafeMap{
        data:  make(map[string]interface{}),
        token: make(chan struct{}, 1), // 初始化令牌
    }