因为使用go过程中会经常使用map存储，多个goroutine会出现资源竞争的问题，所以写个demo测试一下不同方式的锁性能开销。
1.环境
MacBook Pro (15-inch, 2016)
2.6 GHz Intel Core i7
16 GB 2133 MHz LPDDR3
golang版本：1.14
2.代码
var (
num = 1000 * 10
gnum = 1000
)
func Test_main(t *testing.T) {
count := 10000
div := int(50) //抽样写比例 1/5
fmt.Println("only read")
testRwmutexReadOnly(count)
testMutexReadOnly(count)
//test sync.map
testSyncMapReadOnly(count)
fmt.Println("write and read")
testRwmutexWriteRead(count, div)
testMutexWriteRead(count, div)
testSyncMapWriteRead(count, div)
fmt.Println("write only")
testRwmutexWriteOnly(count)
testMutexWriteOnly(count)
testSyncMapWriteOnly(count)
}
func testRwmutexReadOnly(count int) {
var w = &sync.WaitGroup{}
var rwmutexTmp = newRwmutex(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
rwmutexTmp.get(in)
}
}()
}
w.Wait()
fmt.Println("testRwmutexReadOnly cost:", time.Now().Sub(t1).String())
}
func testRwmutexWriteOnly(count int) {
var w = &sync.WaitGroup{}
var rwmutexTmp = newRwmutex(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
rwmutexTmp.set(in, in)
}
}()
}
w.Wait()
fmt.Println("testRwmutexWriteOnly cost:", time.Now().Sub(t1).String())
}
func testRwmutexWriteRead(count, div int) {
var w = &sync.WaitGroup{}
var rwmutexTmp = newRwmutex(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
if i%div != 0 {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
rwmutexTmp.get(in)
}
}()
} else {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
rwmutexTmp.set(in, in)
}
}()
}
}
w.Wait()
fmt.Println("testRwmutexWriteRead cost:", time.Now().Sub(t1).String())
}
func testMutexReadOnly(count int) {
var w = &sync.WaitGroup{}
var mutexTmp = newMutex(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.get(in)
}
}()
}
w.Wait()
fmt.Println("testMutexReadOnly cost:", time.Now().Sub(t1).String())
}
func testMutexWriteOnly(count int) {
var w = &sync.WaitGroup{}
var mutexTmp = newMutex(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.set(in, in)
}
}()
}
w.Wait()
fmt.Println("testMutexWriteOnly cost:", time.Now().Sub(t1).String())
}
func testMutexWriteRead(count, div int) {
var w = &sync.WaitGroup{}
var mutexTmp = newMutex(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
if i%div != 0 {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.get(in)
}
}()
} else {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.set(in, in)
}
}()
}
}
w.Wait()
fmt.Println("testMutexWriteRead cost:", time.Now().Sub(t1).String())
}
func testSyncMapReadOnly(count int) {
var w = &sync.WaitGroup{}
var mutexTmp = newSyncMap(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.Load(in)
}
}()
}
w.Wait()
fmt.Println("testSyncMapReadOnly cost:", time.Now().Sub(t1).String())
}
func testSyncMapWriteOnly(count int) {
var w = &sync.WaitGroup{}
var mutexTmp = newSyncMap(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.Store(in, in)
}
}()
}
w.Wait()
fmt.Println("testSyncMapWriteOnly cost:", time.Now().Sub(t1).String())
}
func testSyncMapWriteRead(count, div int) {
var w = &sync.WaitGroup{}
var mutexTmp = newSyncMap(count)
w.Add(gnum)
t1 := time.Now()
for i := 0; i < gnum; i++ {
if i%div != 0 {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.Load(in)
}
}()
} else {
go func() {
defer w.Done()
for in := 0; in < num; in++ {
mutexTmp.Store(in, in)
}
}()
}
}
w.Wait()
fmt.Println("testSyncMapWriteRead cost:", time.Now().Sub(t1).String())
}
func newRwmutex(count int) *rwmutex {
var t = &rwmutex{}
t.mu = &sync.RWMutex{}
t.ipmap = make(map[int]int, count)
for i := 0; i < count; i++ {
t.ipmap[i] = 0
}
return t
}
type rwmutex struct {
mu *sync.RWMutex
ipmap map[int]int
}
func (t *rwmutex) get(i int) int {
t.mu.RLock()
defer t.mu.RUnlock()
return t.ipmap[i]
}
func (t *rwmutex) set(k, v int) {
t.mu.Lock()
defer t.mu.Unlock()
t.ipmap[k] = v
}
func newMutex(count int) *mutex {
var t = &mutex{}
t.mu = &sync.Mutex{}
t.ipmap = make(map[int]int, count)
for i := 0; i < count; i++ {
t.ipmap[i] = 0
}
return t
}
func newSyncMap(count int) *sync.Map {
var t = &sync.Map{}
for i := 0; i < count; i++ {
t.Store(i, 0)
}
return t
}
type mutex struct {
mu *sync.Mutex
ipmap map[int]int
}
func (t *mutex) get(i int) int {
t.mu.Lock()
defer t.mu.Unlock()
return t.ipmap[i]
}
func (t *mutex) set(k, v int) {
t.mu.Lock()
defer t.mu.Unlock()
k = k % 100
t.ipmap[k] = v
}
3.测试结果
//测试结果
//only read
testRwmutexReadOnly cost: 506.182734ms
testMutexReadOnly cost: 1.970860548s
testSyncMapReadOnly cost: 113.849084ms
//write and read
testRwmutexWriteRead cost: 1.827954707s
testMutexWriteRead cost: 2.074191088s
testSyncMapWriteOnly cost: 4.387804708s
//抽样写比例 1/5
//write and read
testRwmutexWriteRead cost: 1.139143888s
testMutexWriteRead cost: 1.965517324s
testSyncMapWriteRead cost: 188.517601ms
//抽样写比例 1/50
//write and read
testRwmutexWriteRead cost: 809.852228ms
testMutexWriteRead cost: 1.903433116s
testSyncMapWriteRead cost: 133.22511ms
//write only
testRwmutexWriteOnly cost: 2.917429869s
testMutexWriteOnly cost: 2.245351033s
testSyncMapWriteRead cost: 315.201658ms
4.结论
只读场景：sync.map > rwmutex >> mutex
读写场景（边读边写）：rwmutex > mutex >> sync.map
读写场景（读80% 写20%）：sync.map > rwmutex > mutex
读写场景（读98% 写2%）：sync.map > rwmutex >> mutex
只写场景：sync.map >> mutex > rwmutex
5.个人建议和使用习惯
一般来讲大部分面临的都是读写场景，关键在于读写的比例。
考虑到编码和代码可读性，如果存储复杂结构体，我仍然倾向于rwmutex；如果是简单结构类型，我倾向选择sync.map。
