Golang并发安全的Map使用方法-Golang-PHP中文网

Golang并发安全的Map使用方法

P粉602998670

发布： 2025-09-05 11:39:01

原创

822人浏览过

并发安全Map需保证多goroutine下数据一致性，Go原生map非并发安全。可通过sync.Mutex加锁实现，但高并发性能差；读多写少时用sync.RWMutex可提升性能，允许多个读、单个写；sync.Map为官方提供的读多写少优化方案，内部用read/dirty双map减少锁竞争，适用key稳定的场景。选择方案需根据读写比例和场景权衡，避免忘记加锁、死锁或误用sync.Map导致性能下降。还可通过channel信号量控制并发访问量，避免锁竞争。

golang并发安全的map使用方法

并发安全的Map，简单来说，就是在多个goroutine同时读写Map时，保证数据的一致性和正确性。Golang内置的Map不是并发安全的，直接并发读写会引发panic。

解决方案：

使用
```
sync.Mutex
```
登录后复制
互斥锁：这是最常见也最基础的方法。
使用
```
sync.RWMutex
```
登录后复制
读写锁：当读操作远多于写操作时，读写锁可以显著提高性能。
使用
```
sync.Map
```
登录后复制
：Golang 1.9 引入的并发安全Map，适用于读多写少的场景。

如何使用

sync.Mutex

登录后复制

实现并发安全Map？

最直接的方法就是用一个互斥锁保护Map的读写操作。

package main

import (
    "fmt"
    "sync"
)

type ConcurrentMap struct {
    sync.Mutex
    data map[string]interface{}
}

func NewConcurrentMap() *ConcurrentMap {
    return &ConcurrentMap{
        data: make(map[string]interface{}),
    }
}

func (m *ConcurrentMap) Set(key string, value interface{}) {
    m.Lock()
    defer m.Unlock()
    m.data[key] = value
}

func (m *ConcurrentMap) Get(key string) (interface{}, bool) {
    m.Lock()
    defer m.Unlock()
    val, ok := m.data[key]
    return val, ok
}

func (m *ConcurrentMap) Delete(key string) {
    m.Lock()
    defer m.Unlock()
    delete(m.data, key)
}

func main() {
    cmap := NewConcurrentMap()

    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            cmap.Set(fmt.Sprintf("key-%d", i), i)
        }(i)
    }

    wg.Wait()

    for i := 0; i < 100; i++ {
        val, ok := cmap.Get(fmt.Sprintf("key-%d", i))
        if ok {
            fmt.Printf("key-%d: %v\n", i, val)
        }
    }
}

登录后复制

这里，

ConcurrentMap

登录后复制

结构体包含一个

sync.Mutex

登录后复制

和一个

map[string]interface{}

登录后复制

。所有对Map的读写操作都必须先获取锁，操作完成后释放锁。虽然简单，但在高并发场景下，锁的竞争会成为性能瓶颈。

立即学习“go语言免费学习笔记（深入）”；

读写锁

sync.RWMutex

登录后复制

能提升性能吗？

当读操作远多于写操作时，

sync.RWMutex

登录后复制

是个不错的选择。它允许多个goroutine同时读取Map，但只允许一个goroutine写入Map。

package main

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

type ConcurrentMap struct {
    sync.RWMutex
    data map[string]interface{}
}

func NewConcurrentMap() *ConcurrentMap {
    return &ConcurrentMap{
        data: make(map[string]interface{}),
    }
}

func (m *ConcurrentMap) Set(key string, value interface{}) {
    m.Lock() // 使用写锁
    defer m.Unlock()
    m.data[key] = value
}

func (m *ConcurrentMap) Get(key string) (interface{}, bool) {
    m.RLock() // 使用读锁
    defer m.RUnlock()
    val, ok := m.data[key]
    return val, ok
}

func (m *ConcurrentMap) Delete(key string) {
    m.Lock() // 使用写锁
    defer m.Unlock()
    delete(m.data, key)
}

func main() {
    cmap := NewConcurrentMap()

    var wg sync.WaitGroup

    // 模拟大量读操作
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            for j := 0; j < 1000; j++ {
                _, _ = cmap.Get(fmt.Sprintf("key-%d", i)) // 忽略返回值
                time.Sleep(time.Microsecond) // 模拟读操作耗时
            }
        }(i)
    }

    // 模拟少量写操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            cmap.Set(fmt.Sprintf("key-%d", i), i)
            time.Sleep(time.Millisecond * 10) // 模拟写操作耗时
        }(i)
    }

    wg.Wait()

    fmt.Println("Finished")
}

登录后复制

可以看到，

Set

登录后复制

和

Delete

登录后复制

方法使用了

Lock

登录后复制

和

Unlock

登录后复制

，而

Get

登录后复制

方法使用了

RLock

登录后复制

和

RUnlock

登录后复制

。读写锁允许并发读，从而提升了性能。

sync.Map

登录后复制

的适用场景和内部原理是什么？

sync.Map

登录后复制

是Golang标准库提供的并发安全Map，专门针对读多写少的场景进行了优化。它的内部实现相当复杂，采用了分段锁和read-only缓存等技术，力求在减少锁竞争的同时，保证数据的一致性。

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

查看详情

sync.Map

登录后复制

的核心思想是空间换时间。它维护了两个Map：

read

登录后复制

和

dirty

登录后复制

。

read

登录后复制

Map是只读的，可以并发访问。当需要写入时，会先尝试更新

read

登录后复制

Map中的数据。如果

read

登录后复制

Map中不存在要更新的key，则会尝试加锁更新

dirty

登录后复制

Map。如果

dirty

登录后复制

Map不存在，则会从

read

登录后复制

Map复制一份数据到

dirty

登录后复制

Map，然后再进行更新。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var sm sync.Map

    // 存储数据
    sm.Store("name", "Alice")
    sm.Store("age", 30)

    // 加载数据
    if name, ok := sm.Load("name"); ok {
        fmt.Println("Name:", name)
    }

    // 删除数据
    sm.Delete("age")

    // 遍历数据
    sm.Range(func(key, value interface{}) bool {
        fmt.Printf("Key: %v, Value: %v\n", key, value)
        return true // 继续遍历
    })

    // LoadOrStore
    actual, loaded := sm.LoadOrStore("city", "New York")
    fmt.Printf("City: %v, Loaded: %v\n", actual, loaded)

    actual, loaded = sm.LoadOrStore("name", "Bob") // Key already exists
    fmt.Printf("Name: %v, Loaded: %v\n", actual, loaded)
}

登录后复制

sync.Map

登录后复制

提供了一些常用的方法：

Load

登录后复制

、

Store

登录后复制

、

Delete

登录后复制

、

Range

登录后复制

和

LoadOrStore

登录后复制

。需要注意的是，

sync.Map

登录后复制

并不适用于写操作非常频繁的场景，因为在写操作较多时，

dirty

登录后复制

Map的复制和更新会带来额外的开销。

如何选择合适的并发安全Map实现？

选择哪种实现方式，取决于具体的应用场景。

如果读写操作都非常频繁，且竞争激烈，那么使用
```
sync.Mutex
```
登录后复制
可能更简单可靠，虽然性能可能稍差。
如果读操作远多于写操作，那么
```
sync.RWMutex
```
登录后复制
可以显著提高性能。
如果读多写少，且对性能要求较高，那么
```
sync.Map
```
登录后复制
是最佳选择。

需要注意的是，

sync.Map

登录后复制

更适合于key相对稳定的场景，如果key的增加和删除非常频繁，那么

sync.Map

登录后复制

的性能可能会下降。在实际应用中，最好根据实际情况进行benchmark测试，选择最适合的实现方式。

并发安全Map的常见坑有哪些？

忘记加锁：这是最常见的错误。在访问Map之前，一定要记得加锁，否则会导致数据竞争。
死锁：如果多个goroutine互相等待对方释放锁，就会导致死锁。
过度使用锁：锁的粒度过大，会导致并发性能下降。
不正确地使用
sync.Map
登录后复制
：
```
sync.Map
```
登录后复制
只适用于读多写少的场景，如果写操作频繁，反而会降低性能。
Range遍历期间修改Map：在
```
sync.Map
```
登录后复制
的
```
Range
```
登录后复制
遍历期间修改Map可能会导致未定义的行为。虽然可以删除当前key，但不建议添加或修改其他key。

除了锁，还有其他并发控制手段吗？

除了锁之外，还可以使用channel来实现并发控制。例如，可以使用一个buffered channel来限制同时访问Map的goroutine数量。

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建一个 buffered channel，容量为 10
    semaphore := make(chan struct{}, 10)
    data := make(map[int]int)
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            // 获取信号量，如果 channel 已满，则阻塞
            semaphore <- struct{}{}
            // 访问共享资源
            data[i] = i * 2
            fmt.Printf("Writing: key=%d, value=%d\n", i, data[i])
            // 释放信号量
            <-semaphore
        }(i)
    }

    wg.Wait()

    fmt.Println("Finished writing.")

    for k, v := range data {
        fmt.Printf("key=%d, value=%d\n", k, v)
    }
}

登录后复制

这种方法可以避免锁的竞争，但需要仔细设计channel的容量，以达到最佳的性能。此外，还可以使用原子操作来实现一些简单的并发控制，例如原子计数器。

总而言之，选择合适的并发控制手段需要根据具体的应用场景进行权衡。

以上就是Golang并发安全的Map使用方法的详细内容，更多请关注php中文网其它相关文章！