golang读写锁与互斥锁的性能比较

shuiyuejiangnan · · 2940 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

长时间来一直以为在读多写少的场景下,读写锁性能必然优于互斥锁,然而情况恰恰相反

不废话了,先上一段测试代码

func main() {
var w = &sync.WaitGroup{}
var num = 50000000
var c = make(chan int, 3000)

var rwmutexTmp = newRwmutex()
w.Add(num)
t1 := time.Now()
for i := 0; i < num; i++ {
c <- 0
go func(index int) {
defer w.Done()
_ = rwmutexTmp.get(index)
//fmt.Println(value)
<-c
}(i)
}
w.Wait()
t2 := time.Now()

var mutexTmp = newMutex()
w.Add(num)
t3 := time.Now()
for i := 0; i < num; i++ {
c <- 0
go func(index int) {
defer w.Done()
t := mutexTmp.get()
_, _ = t[index]
//fmt.Println(ok)
<-c
}(i)
}
w.Wait()
t4 := time.Now()
fmt.Println("rwmutex cost:", t2.Sub(t1).String())
fmt.Println("mutex cost:", t4.Sub(t3).String())
}

type rwmutex struct {
mu *sync.RWMutex
ipmap map[int]int
}

type mutex struct {
mu *sync.Mutex
ipmap map[int]int
}

func (t *rwmutex) get(i int) int {
t.mu.RLock()
defer t.mu.RUnlock()

return t.ipmap[i]
}


func (t *mutex) get() map[int]int {
t.mu.Lock()
defer t.mu.Unlock()

return t.ipmap
}

func newRwmutex() *rwmutex {
var t = &rwmutex{}
t.mu = &sync.RWMutex{}
t.ipmap = make(map[int]int, 100)

for i := 0; i < 100; i++ {
t.ipmap[i] = 0
}
return t
}

func newMutex() *mutex {
var t = &mutex{}
t.mu = &sync.Mutex{}
t.ipmap = make(map[int]int, 100)

for i := 0; i < 100; i++ {
t.ipmap[i] = 0
}
return t
}

各加锁5000万次,时间比较如下:

go run test_rwmutex_mutex.go 

  rwmutex cost: 22.403487195s

  mutex cost: 21.636404963s

go run test_rwmutex_mutex.go 

  rwmutex cost: 22.3359224s

  mutex cost: 21.931208658s

 

在某些场景下,互斥锁要比读写锁更快!!!




有疑问加站长微信联系(非本文作者)

本文来自:博客园

感谢作者:shuiyuejiangnan

查看原文:golang读写锁与互斥锁的性能比较

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

2940 次点击  
加入收藏 微博
2 回复  |  直到 2020-12-14 10:53:19
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传