Go语言中Map的并发安全操作指南

package main

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

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

// NewConcurrentMap 创建一个新的ConcurrentMap
func NewConcurrentMap() *ConcurrentMap {
    return &ConcurrentMap{
        data: make(map[string]interface{}),
    }
}

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

// Load 获取键对应的值
func (cm *ConcurrentMap) Load(key string) (interface{}, bool) {
    cm.mu.RLock()         // 获取读锁
    defer cm.mu.RUnlock() // 确保读锁被释放
    val, ok := cm.data[key]
    return val, ok
}

// Delete 删除键值对
func (cm *ConcurrentMap) Delete(key string) {
    cm.mu.Lock()
    defer cm.mu.Unlock()
    delete(cm.data, key)
}

// Iterate 遍历map
func (cm *ConcurrentMap) Iterate(f func(key string, value interface{})) {
    cm.mu.RLock()
    defer cm.mu.RUnlock()
    // 在持有读锁期间进行迭代，确保数据一致性
    for k, v := range cm.data {
        f(k, v)
    }
}

func main() {
    cmap := NewConcurrentMap()

    // 启动多个写入goroutine
    for i := 0; i < 5; i++ {
        go func(id int) {
            for j := 0; j < 100; j++ {
                key := fmt.Sprintf("key_%d_%d", id, j)
                value := fmt.Sprintf("value_from_writer_%d_%d", id, j)
                cmap.Store(key, value)
                time.Sleep(time.Millisecond * 5)
            }
        }(i)
    }

    // 启动多个读取goroutine
    for i := 0; i < 5; i++ {
        go func(id int) {
            for j := 0; j < 50; j++ {
                key := fmt.Sprintf("key_%d_%d", id%5, j) // 尝试读取可能存在的键
                if val, ok := cmap.Load(key); ok {
                    // fmt.Printf("Reader %d: Loaded %s = %v\n", id, key, val)
                }
                time.Sleep(time.Millisecond * 10)
            }
        }(i)
    }

    // 启动一个迭代goroutine
    go func() {
        for {
            fmt.Println("--- Map Content ---")
            cmap.Iterate(func(k string, v interface{}) {
                // fmt.Printf("  %s: %v\n", k, v)
            })
            fmt.Println("-------------------")
            time.Sleep(time.Second)
        }
    }()

    // 主goroutine等待一段时间，观察并发操作
    time.Sleep(time.Second * 5)
    fmt.Println("Final map size:", len(cmap.data)) // 直接访问data是危险的，但这里只是为了演示最终大小
}

package main

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

type TokenSafeMap struct {
    data map[string]interface{}
    // 令牌通道，容量为1表示同一时间只有一个goroutine能访问map
    accessToken chan struct{}
}

func NewTokenSafeMap() *TokenSafeMap {
    m := &TokenSafeMap{
        data:        make(map[string]interface{}),
        accessToken: make(chan struct{}, 1),
    }
    m.accessToken <- struct{}{} // 初始化时放入一个令牌
    return m
}

func (tsm *TokenSafeMap) Store(key string, value interface{}) {
    <-tsm.accessToken // 获取令牌，独占访问
    defer func() {
        tsm.accessToken <- struct{}{} // 释放令牌
    }()
    tsm.data[key] = value
}

func (tsm *TokenSafeMap) Load(key string) (interface{}, bool) {
    <-tsm.accessToken // 获取令牌
    defer func() {
        tsm.accessToken <- struct{}{} // 释放令牌
    }()
    val, ok := tsm.data[key]
    return val, ok
}

func main() {
    tsm := NewTokenSafeMap()
    var wg sync.WaitGroup

    // 启动写入goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 10; j++ {
                key := fmt.Sprintf("k%d-%d", id, j)
                value := fmt.Sprintf("v%d-%d", id, j)
                tsm.Store(key, value)
                time.Sleep(time.Millisecond * 5)
            }
        }(i)
    }

    // 启动读取goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 10; j++ {
                key := fmt.Sprintf("k%d-%d", id%5, j)
                if val, ok := tsm.Load(key); ok {
                    // fmt.Printf("Reader %d: %s = %v\n", id, key, val)
                }
                time.Sleep(time.Millisecond * 10)
            }
        }(i)
    }

    wg.Wait()
    fmt.Println("All operations finished.")
    // 最终检查map内容 (需要获取令牌才能安全访问)
    <-tsm.accessToken
    fmt.Printf("Final map size: %d\n", len(tsm.data))
    tsm.accessToken <- struct{}{}
}