Go Map并发安全性深度解析与同步策略

package main

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

// ConcurrentMap 封装了 Go map 并提供了并发安全的访问方法
type ConcurrentMap struct {
    mu    sync.RWMutex
    data  map[string]int
}

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

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

// Get 获取键对应的值
func (cm *ConcurrentMap) Get(key string) (int, 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)
}

// Len 返回 map 的长度
func (cm *ConcurrentMap) Len() int {
    cm.mu.RLock() // 获取读锁
    defer cm.mu.RUnlock() // 释放读锁
    return len(cm.data)
}

func main() {
    cmap := NewConcurrentMap()
    var wg sync.WaitGroup

    // 启动多个goroutine进行写操作
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", id)
            cmap.Set(key, id)
            fmt.Printf("Goroutine %d: Set %s=%d\n", id, key, id)
        }(i)
    }

    // 启动多个goroutine进行读操作
    for i := 0; i < 50; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", id*2) // 尝试读取一些存在的键
            val, ok := cmap.Get(key)
            if ok {
                fmt.Printf("Goroutine %d: Get %s=%d\n", id, key, val)
            } else {
                fmt.Printf("Goroutine %d: Key %s not found\n", id, key)
            }
        }(i)
    }

    wg.Wait()
    fmt.Printf("Final map length: %d\n", cmap.Len())

    // 验证某个键的值
    val, ok := cmap.Get("key-50")
    if ok {
        fmt.Printf("Value for key-50: %d\n", val)
    }
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map // 声明一个 sync.Map

    var wg sync.WaitGroup

    // 写入操作
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("user:%d", id)
            value := fmt.Sprintf("name-%d", id)
            m.Store(key, value) // 存储键值对
            fmt.Printf("Goroutine %d: Stored %s=%s\n", id, key, value)
        }(i)
    }

    // 读取操作
    for i := 0; i < 50; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("user:%d", id*2) // 尝试读取一些存在的键
            val, ok := m.Load(key) // 加载键值对
            if ok {
                fmt.Printf("Goroutine %d: Loaded %s=%s\n", id, key, val)
            } else {
                fmt.Printf("Goroutine %d: Key %s not found\n", id, key)
            }
        }(i)
    }

    wg.Wait()

    // 遍历 sync.Map (Range方法)
    fmt.Println("\n--- Traversing sync.Map ---")
    m.Range(func(key, value interface{}) bool {
        fmt.Printf("Key: %v, Value: %v\n", key, value)
        return true // 返回 true 继续遍历，返回 false 停止遍历
    })

    // 尝试删除一个键
    fmt.Println("\n--- Deleting a key ---")
    m.Delete("user:10")
    _, ok := m.Load("user:10")
    if !ok {
        fmt.Println("Key user:10 successfully deleted.")
    }
}