Golang数据结构：如何优化map的并发访问性能-Golang-PHP中文网

Golang数据结构：如何优化map的并发访问性能

裘德小鎮的故事

发布： 2025-07-03 11:47:02

原创

283人浏览过

在并发环境下优化golang的map性能可通过使用读写锁、分片map、sync.map或原子操作实现。1. 使用读写锁（rwmutex）允许多个goroutine同时读取，适用于读多写少的场景；2. 分片map通过将数据分配到多个带独立锁的小map中减少竞争，适合写操作较频繁的情况；3. sync.map是标准库提供的并发安全结构，内部采用读写分离和原子操作，在读多写少且key分布均匀时性能优异；4. 原子操作适用于简单计数器或状态标志，避免锁开销；选择具体实现应根据实际场景进行基准测试以确定最优方案。

Golang数据结构：如何优化map的并发访问性能

在并发环境下，Golang的map并非线程安全。优化并发访问性能的关键在于减少锁的竞争，或使用更适合并发场景的数据结构。

解决方案

使用读写锁（RWMutex）： 将标准的互斥锁（Mutex）替换为读写锁，允许多个goroutine同时读取map，但在写入时独占访问。这在读多写少的场景下能显著提升性能。

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

import (
 "sync"
)

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

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

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

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

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

登录后复制

分片Map（Sharded Map）： 将map分割成多个小的map（分片），每个分片由一个独立的锁保护。根据key的哈希值将数据分配到不同的分片，从而减少锁的竞争。

import (
 "hash/crc32"
 "sync"
)

const shardCount = 32 // 分片数量，可根据实际情况调整

type ShardedMap struct {
 shards []*shard
}

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

func NewShardedMap() *ShardedMap {
 sm := &ShardedMap{
     shards: make([]*shard, shardCount),
 }
 for i := 0; i < shardCount; i++ {
     sm.shards[i] = &shard{data: make(map[string]interface{})}
 }
 return sm
}

func (sm *ShardedMap) getShard(key string) *shard {
 index := uint(crc32.ChecksumIEEE([]byte(key))) % uint(shardCount)
 return sm.shards[index]
}

func (sm *ShardedMap) Get(key string) (interface{}, bool) {
 shard := sm.getShard(key)
 shard.RLock()
 defer shard.RUnlock()
 val, ok := shard.data[key]
 return val, ok
}

func (sm *ShardedMap) Set(key string, value interface{}) {
 shard := sm.getShard(key)
 shard.Lock()
 defer shard.Unlock()
 shard.data[key] = value
}

func (sm *ShardedMap) Delete(key string) {
 shard := sm.getShard(key)
 shard.Lock()
 defer shard.Unlock()
 delete(shard.data, key)
}

登录后复制

使用sync.Map： Golang标准库提供的sync.Map本身就是并发安全的，它通过原子操作和锁的结合，在某些场景下能提供比读写锁更好的性能。尤其是在读多写少，且key的分布比较均匀的情况下。

Android 本地数据存储中文WORD版
本文档主要讲述的是Android 本地数据存储；对于需要跨应用程序执行期间或生命期而维护重要信息的应用程序来说，能够在移动设备上本地存储数据是一种非常关键的功能。作为一名开发人员，您经常需要存储诸如用户首选项或应用程序配置之类的信息。您还必须根据一些特征（比如访问可见性）决定是否需要涉及内部或外部存储器，或者是否需要处理更复杂的、结构化的数据类型。跟随本文学习 Android 数据存储 API，具体来讲就是首选项、SQLite 和内部及外部内存 API。希望本文档会给有需要的朋友带来帮助；感兴趣的朋友可以

0

查看详情
```
import "sync"

var m sync.Map

func main() {
 // Store
 m.Store("key1", "value1")

 // Load
 value, ok := m.Load("key1")
 if ok {
     println(value.(string))
 }

 // Delete
 m.Delete("key1")

 // Range
 m.Range(func(key, value interface{}) bool {
     println(key.(string), value.(string))
     return true // 继续迭代，返回false则停止
 })
}
```
登录后复制
原子操作： 对于一些简单的计数器或状态标志，可以使用原子操作来避免锁的使用。atomic包提供了诸如atomic.AddInt64、atomic.LoadInt64等函数，它们是线程安全的。
```
import "sync/atomic"

var counter int64

func incrementCounter() {
 atomic.AddInt64(&counter, 1)
}

func getCounter() int64 {
 return atomic.LoadInt64(&counter)
}
```
登录后复制

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

选择哪种并发Map实现取决于你的具体使用场景。sync.Map在读多写少的情况下表现良好，并且不需要预先知道key的数量。分片Map在写操作比较频繁，且可以接受一定的内存开销的情况下，能够提供更好的性能。读写锁则是一个通用的选择，适用于读写比例不确定的场景。在选择时，最好进行基准测试，以确定哪种实现最适合你的应用。

分片Map的分片数量如何确定？

分片数量的选择是一个需要权衡的问题。分片越多，锁的竞争越少，并发性能越高，但同时也会增加内存开销。一种常见的做法是根据预期的并发线程数和数据量来确定分片数量。例如，如果预计有32个并发线程，可以尝试将分片数量设置为32或其倍数。另一个方法是进行性能测试，观察不同分片数量下的性能表现，找到一个最佳值。