go 分段锁ConcurrentMap，map+读写锁，sync.map的效率测试

最新推荐文章于 2024-05-21 12:23:23 发布
最新推荐文章于 2024-05-21 12:23:23 发布
阅读量4.5k 收藏 5
点赞数 2
分类专栏： Go语言 文章标签： go concurrentmap效率 go sync.map效率 go map效率
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzf279533105/article/details/98636679
版权

分段锁ConcurrentMap的实现请参考笔者的另外一篇博客：

go 分段锁ConcurrentMap的实现源码

效率测试结论：

1. go自带的map不是多协程安全的

2. 分段锁ConcurrentMap是多协程安全的，且效率最高；sync.map效率次之，传统的map+读写锁效率最低

3. ConcurrentMap中锁的个数越多，效率越高，因为争夺同一把锁的概率降低了

测试流程：

1. 产生1万个key-value对，加入到各个测试map中

2. 开始计时

3. 开启两个协程，一个写协程随机赋值10万次，一个读协程随机访问10万次

4. 结束计时，打印出耗时，内存操作等信息

测试结果如下图(红框处是每次测试的耗时)：

源码如下：

测试的源码main_test.go

package main

import (
	"math/rand"
	"strconv"
	"sync"
	"testing"
)

// 10万次的赋值,10万次的读取
var times int = 100000

// 测试ConcurrentMap
func BenchmarkTestConcurrentMap(b *testing.B) {
	for k := 0; k < b.N; k++ {
		b.StopTimer()
		// 产生10000个不重复的键值对(string -> int)
		testKV := map[string]int{}
		for i := 0; i < 10000; i++ {
			testKV[strconv.Itoa(i)] = i
		}

		// 新建一个ConcurrentMap
		pMap := NewConcurrentMap()

		// set到map中
		for k, v := range testKV {
			pMap.Set(k, v)
		}

		// 开始计时
		b.StartTimer()

		wg := sync.WaitGroup{}
		wg.Add(2)

		// 赋值
		go func() {
			// 对随机key,赋值times次
			for i := 0; i < times; i++ {
				index := rand.Intn(times)
				pMap.Set(strconv.Itoa(index), index+1)
			}
			wg.Done()
		}()

		// 读取
		go func() {
			// 对随机key,读取times次
			for i := 0; i < times; i++ {
				index := rand.Intn(times)
				pMap.Get(strconv.Itoa(index))
			}
			wg.Done()
		}()

		// 等待两个协程处理完毕
		wg.Wait()
	}
}

// 测试map加锁
func BenchmarkTestMap(b *testing.B) {
	for k := 0; k < b.N; k++ {
		b.StopTimer()
		// 产生10000个不重复的键值对(string -> int)
		testKV := map[string]int{}
		for i := 0; i < 10000; i++ {
			testKV[strconv.Itoa(i)] = i
		}

		// 新建一个MutexMap
		pMap := NewMutexMap()

		// set到map中
		for k, v := range testKV {
			pMap.Set(k, v)
		}

		// 开始计时
		b.StartTimer()

		wg := sync.WaitGroup{}
		wg.Add(2)
		// 赋值
		go func() {
			// 对随机key,赋值100万次
			for i := 0; i < times; i++ {
				index := rand.Intn(times)
				pMap.Set(strconv.Itoa(index), index+1)
			}
			wg.Done()
		}()

		// 读取
		go func() {
			// 对随机key,读取100万次
			for i := 0; i < times; i++ {
				index := rand.Intn(times)
				pMap.Get(strconv.Itoa(index))
			}
			wg.Done()
		}()

		// 等待两个协程处理完毕
		wg.Wait()
	}
}

// 测试sync.map
func BenchmarkTestSyncMap(b *testing.B) {
	for k := 0; k < b.N; k++ {
		b.StopTimer()
		// 产生10000个不重复的键值对(string -> int)
		testKV := map[string]int{}
		for i := 0; i < 10000; i++ {
			testKV[strconv.Itoa(i)] = i
		}

		// 新建一个sync.Map
		pMap := &sync.Map{}

		// set到map中
		for k, v := range testKV {
			pMap.Store(k, v)
		}

		// 开始计时
		b.StartTimer()

		wg := sync.WaitGroup{}
		wg.Add(2)

		// 赋值
		go func() {
			// 对随机key,赋值10万次
			for i := 0; i < times; i++ {
				index := rand.Intn(times)
				pMap.Store(strconv.Itoa(index), index+1)
			}
			wg.Done()
		}()

		// 读取
		go func() {
			// 对随机key,读取10万次
			for i := 0; i < times; i++ {
				index := rand.Intn(times)
				pMap.Load(strconv.Itoa(index))
			}
			wg.Done()
		}()

		// 等待两个协程处理完毕
		wg.Wait()
	}
}

分段锁map的实现源码concurrentmap.go

package main

import (
	"sync"
)

// 总的map
type ConcurrentMap []*ConcurrentMapShared

// 默认分片数
const SHARE_COUNT int = 64

// 单个map分片
type ConcurrentMapShared struct {
	items map[string]interface{} // 本分片内的map
	mu    sync.RWMutex           // 本分片的专用锁
}

// 新建一个map
func NewConcurrentMap() *ConcurrentMap {
	m := make(ConcurrentMap, SHARE_COUNT)
	for i := 0; i < SHARE_COUNT; i++ {
		m[i] = &ConcurrentMapShared{
			items: map[string]interface{}{},
		}
	}
	return &m
}

// GetSharedMap 获取key对应的map分片
func (m ConcurrentMap) GetSharedMap(key string) *ConcurrentMapShared {
	return m[uint(fnv32(key))%uint(SHARE_COUNT)]
}

// hash函数
func fnv32(key string) uint32 {
	hash := uint32(2166136261)
	prime32 := uint32(16777619)
	for i := 0; i < len(key); i++ {
		hash *= prime32
		hash ^= uint32(key[i])
	}
	return hash
}

// Set 设置key,value
func (m ConcurrentMap) Set(key string, value interface{}) {
	sharedMap := m.GetSharedMap(key) // 找到对应的分片map
	sharedMap.mu.Lock()              // 加锁(全锁定)
	sharedMap.items[key] = value     // 赋值
	sharedMap.mu.Unlock()            // 解锁
}

// Get 获取key对应的value
func (m ConcurrentMap) Get(key string) (value interface{}, ok bool) {
	sharedMap := m.GetSharedMap(key) // 找到对应的分片map
	sharedMap.mu.RLock()             // 加锁(读锁定)
	value, ok = sharedMap.items[key] // 取值
	sharedMap.mu.RUnlock()           // 解锁
	return value, ok
}

// Count 统计key个数
func (m ConcurrentMap) Count() int {
	count := 0
	for i := 0; i < SHARE_COUNT; i++ {
		m[i].mu.RLock() // 加锁(读锁定)
		count += len(m[i].items)
		m[i].mu.RUnlock() // 解锁
	}
	return count
}

// Keys1 所有的key方法1(方法:遍历每个分片map,读取key;缺点:量大时,阻塞时间较长)
func (m ConcurrentMap) Keys1() []string {
	count := m.Count()
	keys := make([]string, count)

	// 遍历所有的分片map
	for i := 0; i < SHARE_COUNT; i++ {
		m[i].mu.RLock() // 加锁(读锁定)
		oneMapKeys := make([]string, len(m[i].items))
		for k := range m[i].items {
			oneMapKeys = append(oneMapKeys, k)
		}
		m[i].mu.RUnlock() // 解锁

		// 汇总到keys
		keys = append(keys, oneMapKeys...)
	}

	return keys
}

// Keys2 所有的key方法2(方法:开多个协程分别对分片map做统计再汇总 优点:量大时,阻塞时间较短)
func (m ConcurrentMap) Keys2() []string {
	count := m.Count()
	keys := make([]string, count)

	ch := make(chan string, count) // 通道,遍历时
	// 单独起一个协程
	go func() {
		wg := sync.WaitGroup{}
		wg.Add(SHARE_COUNT)

		for i := 0; i < SHARE_COUNT; i++ {
			// 每个分片map,单独起一个协程进行统计
			go func(ms *ConcurrentMapShared) {
				defer wg.Done()

				ms.mu.RLock() // 加锁(读锁定)
				for k := range ms.items {
					ch <- k // 压入通道
				}
				ms.mu.RUnlock() // 解锁
			}(m[i])
		}

		// 等待所有协程执行完毕
		wg.Wait()
		close(ch) // 一定要关闭通道,因为不关闭的话,后面的range不会结束!!!
	}()

	// 遍历通道,压入所有的key
	for k := range ch {
		keys = append(keys, k)
	}
	return keys
}

map+读写锁的实现源码mutexmap.go

package main

import (
	"sync"
)

// 对外暴露的map
type MutexMap struct {
	items map[string]interface{} // 为了和上面的ConcurrentMap做比较,都采用string->interface的方式
	mu    *sync.RWMutex          // 读写锁
}

// 新建一个map
func NewMutexMap() *MutexMap {
	return &MutexMap{
		items: map[string]interface{}{},
		mu:    new(sync.RWMutex),
	}
}

// Set 设置key,value
func (m MutexMap) Set(key string, value interface{}) {
	m.mu.Lock()          // 加锁(全锁定)
	m.items[key] = value // 赋值
	m.mu.Unlock()        // 解锁
}

// Get 获取key对应的value
func (m MutexMap) Get(key string) (value interface{}, ok bool) {
	m.mu.RLock()             // 加锁(读锁定)
	value, ok = m.items[key] // 取值
	m.mu.RUnlock()           // 解锁
	return value, ok
}

// Count 统计key个数
func (m MutexMap) Count() int {
	m.mu.RLock() // 加锁(读锁定)
	count := len(m.items)
	m.mu.RUnlock() // 解锁
	return count
}

// Keys 所有的key
func (m MutexMap) Keys() []string {
	m.mu.RLock() // 加锁(读锁定)
	keys := make([]string, len(m.items))
	for k := range m.items {
		keys = append(keys, k)
	}
	m.mu.RUnlock() // 解锁

	return keys
}

 

YZF_Kevin
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go语言工具_Concurrent Map
qq1613957812的博客
06-18 808
Concurrent Map 背景 map是平时项目中经常用到的数据类型，但是如果
syncmap:使用代码生成的Go sync.Map的类型化实现
05-06
使用代码生成的Go sync.Map类型化实现。 安装 go get -u github.com/a8m/syncmap@master 例子： 使用CLI $ syncmap -name IntMap " map[int]int " $ syncmap -name RequestMap -pkg mypkg " map[string]*...
go中实现并发安全的ConcurrentMap
idwtwt的专栏
05-19 8342
之前在项目中需要在内存中用map维护诸多设备结构信息（包含设备名，设备状态，控制信道长连接，以及长短数据信道连接，资源信息指针等）。我们知道go实现的map不是多协程安全的（并发访问可能导致）：fatal error:concurrent map read and map write 为了避免这个问题，在map结构中添加了读写说来保护临界区，如下：//管理所有设备的MAP结构 type RWDev...
【Go专家编程——常见数据结构的实现原理sync.Map】
最新发布
qq_45467608的博客
05-21 593
sync.Map是一种并发安全的map，相较于原生map。sync.Map在并发读写时不会触发panic，它可以减轻程序员的负担。不用再小心翼翼地处理各种锁。
golang的加锁map与syncmap性能分析
如切如磋，如琢如磨
03-23 2558
syncmap是golang1.5引入的线程安全的map，以下是测试程序，结论： 不建议使用sync.map, 原因： 1. 性能不及加锁的map, 2. 对json不友好 测试程序： package main_test import ( "math/rand" "sync" "testing" ) type WrapedMap struct { lck sync.Mutex m ...
使用go_concurrent_map 管理 并发更新缓存
robinfoxnan的专栏
04-19 324
在后台服务中，为了提速，我在内存还做了一个告诉缓存来管理用户信息，根据更新通知，或者定时去redis中同步信息，那么在加载或者更新某个用户元素时，要防止并发，这个类在插入时候，可以检测是否存在，并通过回调函数来决定是插入还是更新；这个加锁已经放在插入函数中完成了；2）去数据库或者redis加载；这里就有个并发重复的可能性；1）如果内存缓存没有；3）添加到内存缓存；
Map 在 Go runtime 中的高效实现
riba2534的博客
07-14 599
什么是映射函数 要明白 map 是如何工作的的，我们需要先讨论一下 map 函数。一个 map 函数用以将一个值映射到另一个值。给定一个值，我们叫 key，它就会返回另外一个值，称为 value。 map(key) → value 现在，map 还没什么用，除非我们放入一些数据。我们需要一个函数来将数据添加到 map 中 insert(map, key, value) 和一个函数从 map 中...
ConcurrentMap.putIfAbsent(key,value)用法实例
08-28
ConcurrentMap.putIfAbsent(key, value) 用法实例 ConcurrentMap.putIfAbsent(key, value) 是一种 atomic 操作，用于在并发环境下安全地将键值对添加到 Map 中。这个方法主要是为了解决 put-if-absent 操作中的 ...
parallel-map：用于go的线程安全并发映射
02-04
在Go 1.9中，引入了sync.Map 。 新的sync.Map与该映射有一些关键区别。 stdlib sync.Map专为仅追加方案而设计。 因此，如果您想将地图用于内存数据库中，则可能会受益于我们的版本。 您可以在golang存储库中了解...
concurrentmap
04-10
go get github.com/chenquan/concurrentmap 导入包： import "github.com/chenquan/concurrentmap" 例子 package main import ( "fmt" "github.com/chenquan/concurrentmap" ) func main () { concurrentMap :=...
Learning+Concurrent+Programming+in+Scala,+2nd+Edition-2017.mobi
03-04
Concurrent and parallel programming have progressed from niche disciplines, of interest only to kernel programming and high-performance computing, to something that every competent programmer must ...
Go concurrent
JunChow
04-22 240
并发是指在同一时间内可以执行多个任务，Golang通过编译器运行时，从语言级别上支持并发特性，因此Golang在语言层面天生支持并发。 Golang的并发通过Goroutine特性来完成的，Goroutine类似于线程，属于用户态的线程。可根据需要创建多个Goroutine并发工作。与传统的线程不同的是，Goroutine是由Golang运行时调度完成的，而线程则是由操作系统调度完成的。 另外，G...
【golang】go-ConcurrentMap实现
niyuelin1990的博客
08-16 2148
用go实现ConcurrentMap // 泛化的Map的接口类型 type GenericMap interface { // 获取给定键值对应的元素值。若没有对应元素值则返回nil。 Get(key interface{}) interface{} // 添加键值对，并返回与给定键值对应的旧的元素值。若没有旧元素值则返回(nil, true)。
《GO并发编程实战》—— Concurrent Map
weixin_33805743的博客
04-05 140
声明：本文是《Go并发编程实战》的样章，感谢图灵授权并发编程网站发布样章，禁止以任何形式转载此文。 我们在本章前面的部分中对Go语言提供的各种传统同步工具和方法进行了逐一的介绍。在本节，我们将运用它们来构造一个并发安全的字典（Map）类型。 我们已经知道，Go语言提供的字典类型并不是并发安全的。因此，我们需要使用一些同步方法对它进行扩展。这看起来并不困难...
go 并发安全map 分段锁实现
papaya的博客
08-05 2964
一. 简言 1.1 go中的map不是并发安全的 1.2 go1.9版本之前，可以使用map+mutex的方式实现并发安全，但是每次操作，无论读取都要加锁，性能不太好 1.3 go 1.9之后，新增了sync.Map，是并发安全的，效率也很高，具体的源码分析可见笔者的另外一篇博客 https://blog.csdn.net/yzf279533105/article/deta...
Go Map(集合)和sync.Map
Steve Wang's blog
12-21 535
Go中的Map对应的数据结构即为哈希表，但它的中文翻译却是集合，这点需要注意。我个人觉得翻译成集合错的很离谱，应该直译成映射。 Go语言中的Map是一种无序的键值对集合。Map可以通过key在O(1)的时间复杂度内进行查询、更改、删除操作，key到value间的映射由哈希函数实现。Go的Map相当于C++的Map，Java的HashMap，Python的Dict。 使用方式类Python的Dict，可以直接map[key]的形式访问元素，直接使用map[key] = vaule赋值形式添加新的元素或对已.
Go 的并发 Concurrency
Ghost_02的博客
08-09 1503
Go 的并发               很多人都是冲着Go的高并发来学习Go的。而gorouting只是由官方实现的一个超级线程池而已，每个实例4-5KB的栈内存占用和由于实现机制而大幅减少创建和销毁的开销。这就是Go高并发的原因。      Go中并发程序依靠的是两个：goroutine和channel。      一个goroutine对新手来说可看作一个线程，但是他又不是一个
锁的效率很低
hificamera的博客
11-03 614
如果用到 锁 的 wait，那么唤醒它的效率极低，为什么呢？但是如果不让它wait，空循环，就会导致线程极度耗费资源，影响其他线程的执行，怎么解决呢
golang的syncMap写入性能差的原因
如切如磋，如琢如磨
08-25 566
syncMap内部设计了read,dirty和mu三个字段，如下 type Map struct { mu Mutex dirty map[interface{}]*entry misses int } 重点关注其中的read read保存只读数据, 其中的amended=true表示read中的数据和dirty中不同,默认false type readOnly struct { m map[interface{}]*entry amended bool // true if the
concurrentMap
09-19
concurrentMap是Java中的接口，它是一个线程安全的Map集合。它提供了一种在并发环境下使用Map的方式，可以安全地被多个线程同时访问和修改。它继承自java.util.Map接口，并添加了一些支持并发操作的方法。 concurrentMap接口定义了一些常用的方法，如put、get、remove等，同时还定义了一些特殊的方法，如putIfAbsent、replace等。这些方法可以保证多线程并发操作时的安全性。 与普通的Map不同，concurrentMap中的操作可以保证原子性。在多线程环境下，多个线程可以同时对concurrentMap进行读操作，也可以同时进行读写或者写写操作，而不会产生冲突或者数据不一致的问题。 concurrentMap接口有一些常用的实现类，如ConcurrentHashMap和ConcurrentSkipListMap。其中ConcurrentHashMap是基于哈希表的实现，而ConcurrentSkipListMap则是基于跳表的实现。这两个实现类在多线程环境下表现良好，并且性能较高。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值