【Go进阶】怎么实现并发安全的map

最新推荐文章于 2024-05-11 14:30:00 发布
最新推荐文章于 2024-05-11 14:30:00 发布
阅读量1.8k 收藏 29
点赞数 23
文章标签： golang 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50562814/article/details/134836475
版权
本文介绍了在Go语言中，如何通过读写锁配合map、分片加锁以及sync.Map来实现并发安全的map。讨论了三种方法的原理、代码实现以及sync.Map在特定场景下的性能优势。
摘要由CSDN通过智能技术生成

go语言提供的数据类型中，只有channel是并发安全的，基础map并不是并发安全的。以下三种方案实现了并发安全的map。

方案一：读写锁+map

实现原理：

给map添加一把读写锁，读操作加读锁进行读取；添加，更新，删除，遍历，获取长度这些操作加写锁后在进行操作。

代码实现：

以下代码是并发map的实现演示：

type RWMap struct {
    sync.RWMutex
    m map[any]any
}

func NewGRWMap() *RWMap {
    return &RWMap{
       m: make(map[any]any),
    }
}
func (m *RWMap) Get(k int) (any, bool) {
    m.RLock()
    defer m.RUnlock()
    v, existed := m.m[k]
    return v, existed
}

func (m *RWMap) Set(k any, v any) {
    m.Lock()
    defer m.Unlock()
    m.m[k] = v
}

func (m *RWMap) Delete(k any) {
    m.Lock()
    defer m.Unlock()
    delete(m.m, k)
}

func (m *RWMap) Len() int {
    m.RLock()
    defer m.RUnlock()
    return len(m.m)
}

func (m *RWMap) Each(f func(k, v any) bool) {
    m.RLock()
    defer m.RUnlock()

    for k, v := range m.m {
       if !f(k, v) {
          return
       }
    }
}

上述代码在读的时候加了个读锁，这个读锁在sync.RWMutex中并没有使用锁，只是将 readerCount这个字段+1。增删改是加了写锁，写锁在sync.RWMutex中每次都需要加锁。
以上可知，读写锁的加锁力度很大，当需要读多写少的情况下可以使用读写锁加map实现并发安全。

方案二：分片加锁

实现原理：

分片加锁的原理就如其名字一样，将一个map分成多个片段（一个片段是一个map），每个片段有自己的锁。

在这里插入图片描述

代码实现：

concurrent-map提供了一种高性能的解决方案：通过对内部map进行分片，降低锁粒度，从而达到最少的锁等待时间(锁冲突)

以下是分片加锁中重要的数据类型的结构体：

var SHARD_COUNT = 32

type ConcurrentMap[K comparable, V any] struct {
	shards   []*ConcurrentMapShared[K, V]
	sharding func(key K) uint32
}

type ConcurrentMapShared[K comparable, V any] struct {
	items        map[K]V
	sync.RWMutex 
}

结构如下图所示：
在这里插入图片描述

上述代码使用泛型实现了不同类型的map[comparable]any 。调用NewWithCustomShardingFunction函数，传入泛型的类型参数和哈希函数，就可以得到一个并发安全的map了。

func create[K comparable, V any](sharding func(key K) uint32) ConcurrentMap[K, V] {
	m := ConcurrentMap[K, V]{
		sharding: sharding,
		shards:   make([]*ConcurrentMapShared[K, V], SHARD_COUNT),
	}
	for i := 0; i < SHARD_COUNT; i++ {
		m.shards[i] = &ConcurrentMapShared[K, V]{items: make(map[K]V)}
	}
	return m
}

func New[V any]() ConcurrentMap[string, V] {
	return create[string, V](fnv32)
}


func NewWithCustomShardingFunction[K comparable, V any](sharding func(key K) uint32) ConcurrentMap[K, V] {
    return create[K, V](sharding)
}

添加过程

在这里插入图片描述

func (m ConcurrentMap[K, V]) Set(key K, value V) {
    shard := m.GetShard(key)
    shard.Lock()
    shard.items[key] = value
    shard.Unlock()
}

func (m ConcurrentMap[K, V]) GetShard(key K) *ConcurrentMapShared[K, V] {
	return m.shards[uint(m.sharding(key))%uint(SHARD_COUNT)]
}

大致流程如上图所示：

  1. 调用sharding得到哈希值。
  2. 对哈希值取模于切片长度，得到对应的分片map。
  3. 对map加写锁进行操作。

其他流程大致一样，大致都是先找“坑”，再进行读写操作。也可以将分片加锁方案简单的理解为是对读写加锁的方案的升级。

方案三：sync.Map

我们先看一下1.21版本的sync.Map的结构体：

type Map struct {
	mu Mutex
	read atomic.Pointer[readOnly]
	dirty map[any]*entry
	misses int
}


type readOnly struct {
	m       map[any]*entry
	amended bool
}


type entry struct {
	p atomic.Pointer[any]
}

这个结构的关系如下图所示：

在这里插入图片描述

应对特殊场景的 sync.Map

在官方文档中指出，在以下两个场景中使用sync.Map，会比使用读写锁+map，的性能好：

  1. 只会增长的缓存系统中，一个key只写入一次而被读很多次；
  2. 多个goroutine为不相交的读，写和重写的键值对。

sync.Map的操作流程

读Load()
func (x *Pointer[T]) Load() *T { return (*T)(LoadPointer(&x.v)) }

func (m *Map) loadReadOnly() readOnly {
    if p := m.read.Load(); p != nil {
       return *p
    }
    return readOnly{}
}

func (m *Map) Load(key any) (value any, ok bool) {
    read := m.loadReadOnly()
    e, ok := read.m[key]
    if !ok && read.amended {
       m.mu.Lock()

       read = m.loadReadOnly()
       e, ok = read.m[key]
       if !ok && read.amended {
          e, ok = m.dirty[key]
          m.missLocked()
       }
       m.mu.Unlock()
    }
    if !ok {
       return nil, false
    }
    return e.load()
}

func (e *entry) load() (value any, ok bool) {
    p := e.p.Load()
    if p == nil || p == expunged {
       return nil, false
    }
    return *p, true
}

func (m *Map) missLocked() {
    m.misses++
    if m.misses < len(m.dirty) {
       return
    }
    m.read.Store(&readOnly{m: m.dirty})
    m.dirty = nil
    m.misses = 0
}

读流程：

先去read中读，有数据直接读取e.load()结束；没有加锁，去dirty中读，e换成dirty的，调用m.missLocked()，判断dirty是否存在这个key，不存在return nil, false；存在e.load().

!ok && read.amended这个判断是在read不存在key并且dirty存在read中没有的数据时为true。
m.missLocked()记录miss的次数，当miss的次数大于m.dirty的长度时将dirty数据给read，dirty清空，miss重置为0。

image.png

写Store()

func (m *Map) Store(key, value any) {
    _, _ = m.Swap(key, value)
}

func (m *Map) Swap(key, value any) (previous any, loaded bool) {
	read := m.loadReadOnly()
	if e, ok := read.m[key]; ok {
		if v, ok := e.trySwap(&value); ok {
			if v == nil {
				return nil, false
			}
			return *v, true
		}
	}

	m.mu.Lock()
	read = m.loadReadOnly()
	if e, ok := read.m[key]; ok {
		if e.unexpungeLocked() {
			// The entry was previously expunged, which implies that there is a
			// non-nil dirty map and this entry is not in it.
			m.dirty[key] = e
		}
		if v := e.swapLocked(&value); v != nil {
			loaded = true
			previous = *v
		}
	} else if e, ok := m.dirty[key]; ok {
		if v := e.swapLocked(&value); v != nil {
			loaded = true
			previous = *v
		}
	} else {
		if !read.amended {
			// We're adding the first new key to the dirty map.
			// Make sure it is allocated and mark the read-only map as incomplete.
			m.dirtyLocked()
			m.read.Store(&readOnly{m: read.m, amended: true})
		}
		m.dirty[key] = newEntry(value)
	}
	m.mu.Unlock()
	return previous, loaded
}


func (m *Map) dirtyLocked() {
	if m.dirty != nil {
		return
	}

	read := m.loadReadOnly()
	m.dirty = make(map[any]*entry, len(read.m))
	for k, e := range read.m {
		if !e.tryExpungeLocked() {
			m.dirty[k] = e
		}
	}
}

写的流程：

先去read看key是否存在；存在：如果key的value值为expunged，返回false，走dirty操作；否则，使用cas原子操作直接赋值，结束流程。

返回false，走dirty操作：先加锁，再走一次read，看是否存在key。

  1. read存在，使用e.unexpungeLocked()使用cas将entry设置为nil,若cas成功，将dirty中的entry设置为nil。使用cas设置value。
  2. read不存在,dirty存在，使用cas设置value。
  3. 以上都不满足（read，dirty都不存在），判断read中是否缺少数据，缺少时给dirty添加key-value；不缺少时调用m.dirtyLocked()，将read中的数据更新到dirty中，将其中删除的数据设置为expunged，之后将read的amended设置为true，最后给dirty添加key-value。

解锁，结束。

在这里插入图片描述

删Delete()

func (m *Map) Delete(key any) {
    m.LoadAndDelete(key)
}

func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
	read := m.loadReadOnly()
	e, ok := read.m[key]
	if !ok && read.amended {
		m.mu.Lock()
		read = m.loadReadOnly()
		e, ok = read.m[key]
		if !ok && read.amended {
			e, ok = m.dirty[key]
			delete(m.dirty, key)
			m.missLocked()
		}
		m.mu.Unlock()
	}
	if ok {
		return e.delete()
	}
	return nil, false
}

func (e *entry) delete() (value any, ok bool) {
	for {
		p := e.p.Load()
		if p == nil || p == expunged {
			return nil, false
		}
		if e.p.CompareAndSwap(p, nil) {
			return *p, true
		}
	}
}

删除流程：

先看read中是否存在，存在，直接调用e.delete()结束

不存在，且read中缺少数据，加锁，再次查看read，存在：解锁，调用e.delete()结束；不存在：删除dirty中的key，再调用m.missLocked()，解锁，若dirty中存在并删除了，还需要调用e.delete()，若dirty不存在key，return结束。

在这里插入图片描述

遍历Range()

func (m *Map) Range(f func(key, value any) bool) {
    read := m.loadReadOnly()
    if read.amended {
       m.mu.Lock()
       read = m.loadReadOnly()
       if read.amended {
          read = readOnly{m: m.dirty}
          m.read.Store(&read)
          m.dirty = nil
          m.misses = 0
       }
       m.mu.Unlock()
    }
    for k, e := range read.m {
       v, ok := e.load()
       if !ok {
          continue
       }
       if !f(k, v) {
          break
       }
    }
}

遍历流程：
获取read，若read的数据全，遍历read，若数据不全，加锁，将dirty数据更新到read中，并将dirty值为nil，misses置0，再遍历read。

在这里插入图片描述

sync.Map安全并发实现

sync.Map在实现并发问题的同时提升性能的几个优化：

  1. 用空间换时间，使用两个map，一个无锁，一个有锁，减少加锁对性能的影响。
  2. 优先从无锁的map中读取，更新，删除。
  3. 动态调整，miss次数多之后，将加锁map数据给无锁map。
  4. 延迟删除，删除一个键值只是进行了软删除，在动态调整时会进行硬删除。
  5. double check，访问有锁map，加锁后再次检查无锁map，是否有数据。
水洗牛仔裤
关注
论go语言如何并发安全的使用map的问题分析
空山新雨后，天气晚来秋
05-22 893
论go语言如何并发安全的使用map的问题分析
Golang 实现一个简单的并发安全的Map
最新发布
m0_70578296的博客
10-09 671
通过一道考题，来实现一个简单的并发安全的Map，以加深对并发编程和channel的理解。要求实现一个map：（1）面向高并发（2）只存在插入和删除操作，时间复杂度为O(1)（3）查询时，若Key存在，直接返回Val；若Key不存在，阻塞直到KV对被放入后，获取Val返回；如果等待指定时长仍未放入，返回超时错误；
读/写锁的实现和应用（高并发状态下的map实现）
昕友软件博客
11-26 256
&#13; 程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。&#13; 按照上面...
Golang之sync.Map 并发安全的map
Linzhongyilisha的专栏
04-12 487
Go 语言自带的字典类型map并不是并发安全的。 Go 1.9 中，正式加入了并发安全的字典类型sync.Map。 这个字典类型提供了一些常用的键值存取操作方法，并保证了这些操作的并发安全。同时，它的存、取、删等操作都可以基本保证在常数时间内执行完毕。换句话说，它们的算法复杂度与map类型一样都是O(1)的。 在有些时候，与单纯使用原生map和互斥锁的方案相比，使用sync.Ma...
golang 中map的并发安全
翔云
02-27 1218
目录1.加锁的map2.使用sync.Map3.参考 golang 自带的map不是并发安全的，并发读写会报错： fatal error: concurrent map read and map write 一般的解决方式是加锁，控制互斥。 1.加锁的map 如下代码所示： package main import ( "fmt" "sync" "time" ) type Map struct { m map[int]int sync.RWMutex } fun
Go语言map使用和并发安全
行走的皮卡丘
03-21 3466
map是一种无序的集合，对应的key （索引）会对应一个value（值），所以这个结构也称为关联数组或字典。
Go Context进阶指南：实现高效并发与优雅超时控制的秘诀
Go语言的并发模型非常灵活，而`Context`是Go并发模型中传递控制信号、截止时间、取消信号的基础。理解`Context`对于编写高效和响应的Go程序至关重要。本章将解释`Context`的基本概念，并展示它如何适应Go的并发范式...
Golang进阶：性能优化与并发编程实战
本篇教程是关于通向Go语言(Golang)的性能优化路径，详细讲解了如何通过实例演示提高代码效率。章节涵盖了多个关键知识点： 1. **字符串**：介绍了字符串操作的基础，包括如何创建和优化字符串处理，可能涉及到字符...
Go语言从入门到进阶实战【源码】.zip
03-10
Go语言，也被称为Golang，是由Google开发的一种静态类型的、编译式的、并发型且具有垃圾回收功能的编程语言。它的设计目标是提高开发效率，同时保持程序的高性能和可靠性。Go语言以其简洁的语法、高效的并发模型以及...
go语言学习笔记 — 进阶 — 并发编程（7）：通道（channel） —— 各种各样的通道
yjk13703623757的博客
10-25 329
单向通道 在声明通道时，我们可以设置只发送或只接收。这种被约束操作方向的通道称为单向通道。 声明单向通道 只发送：chan<-，只接收：<-chan var 通道实例 chan<- 元素类型 // 只发送数据 var 通道实例 <-chan 元素类型 // 只接受数据 通道实例即通道变量；元素类型为通道传输的数据类型。 单向通道使用实例 只能发送数据的通道类型为chan<- ch := make(chan int) // 创建一个通道实例 var chSen
golang 并发安全Map以及分段锁的实现方法
09-19
主要介绍了golang 并发安全Map以及分段锁的实现方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
golang学习笔记（进阶篇）
lcynone的博客
01-13 815
Golang学习笔记_进阶篇
golang并发访问map安全问题
qq_37638125的博客
04-18 1021
Go语言规范并未保证在并发写情况下map的行为。因此，如果发生并发写，程序可能会出现未定义的行为，如panic（数据竞争检测器检测到问题时）、数据不一致、程序崩溃等。这些行为是不可预测的，且难以调试。
Go并发编程-map
caoPengFlying的博客
04-19 404
Go并发编程-map ​ hash table的结构时日常开发中经常使用的，在go中内建了map的类型。本文介绍下在并发情况下的map 使用map的常见错误 map必须初始化后使用，否则会panic // 直接使用忘记初始化 func main() { var m map[int]int m[100] = 100 } // 结构体中忘记初始化 type Counter struct { Website string Start time.Time PageCount
golang的map是不是并发安全的？怎么保证安全？
qq_45927881的博客
02-25 1287
参考链接map 的并发不安全主要是因为无锁机制： map 的底层数据结构是一个哈希表，当多个 Goroutine 并发地对 map 进行读写操作时，可能会导致数据竞争（DataRace）。因为 map 没有内置的锁机制来保护并发访问，所以在并发读写时可能会造成数据不一致或损坏。非原子操作： 尽管 map 的操作看起来是单个的语句，比如 m[key] = value 和 delete(m,key)，但实际上它们都不是原子操作。
golang之map并发访问
techdashen的博客
10-12 1406
即定义一个新的结构体,为该结构体实现两个方法,在方法里使用sync包的Mutex或RWMutex来做加锁保证并发安全.(和缓存的做法很类似：先从缓存中取，如果没有则从数据库中读，读回来存入缓存，下次就可以从缓存中取到了。可以用sync.Mutex (互斥锁)，或者sync.RWMutex(读写锁)来"重构"map,map 不是并发安全的数据结构，倘若存在并发读写行为，会抛出 fatal error.并发安全也称线程安全,如果在并发中出现了数据的丢失或错乱,就是并发不安全。Store为写,Load为读。
golang中三种线程安全的MAP
tiancityycf的专栏
05-11 3141
123456789101112131415161718192021222324252627typestructmu Mutex// 基本上你可以把它看成一个安全的只读的map// 它包含的元素其实也是通过原子操作更新的，但是已删除的entry就需要加锁操作了// 包含需要加锁才能访问的元素// 包括所有在read字段中但未被expunged（删除）的元素以及新加的元素。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值