golang 并发锁的陷阱

yanqiufang

错误代码示例
　　

package main　　

　　
import (
　　"sync"
　　"strconv"
　　"fmt"
　　
)
　　

　　
type Node struct {
　　sync.Mutex
　　Data map[string]string
　　
}
　　

　　
var Cache []Node;
　　

　　
func main() {
　　Cache = make([]Node, 2);
　　Cache[0] = Node{Data : make(map[string]string)}
　　Cache[1] = Node{Data : make(map[string]string)}
　　

　　wg := sync.WaitGroup{}
　　for i := 0; i < 10000; i++ {
　　wg.Add(1)
　　go func (index int) {
　　defer wg.Done()
　　j := index % 2
　　node := Cache[j]
　　node.Lock()
　　defer node.Unlock()
　　node.Data[strconv.Itoa(index)] = strconv.Itoa(index)
　　}(i)
　　}
　　wg.Wait();
　　fmt.Println(Cache[0])
　　
}
　　

　　看上面这块代码逻辑很简单，并发10000个协程对Cache中的Data进行赋值，偶数index就赋值到第0个map，奇数就赋值第1个map，并且map赋值的时候都加了锁，但是在golang 1.8 运行的时候会爆出如下错误
　　

fatal error: concurrent map writes　　
fatal error: concurrent map writes
　　

　　
goroutine 26 [running]:
　　
runtime.throw(0x10b4392, 0x15)
　　
......
　　

　　为什么加锁了仍然会报cuncurrent map wirtes，这一定是golang 1.8 的bug（开玩笑的……）！

错误原因
　　主要原因是golang的struct 在赋值的时候是进行浅拷贝，把结构体的成员进行了copy，Node 结构体有两个成员
　　

type Node struct {　　sync.Mutex
　　Data map[string]string
　　
}
　　

　　我们从slice中把Node拿出来的时候，其实是copy了一份Node，Map是指针类型的，所以多份copy其实是操作一份map，但是sync.Mutex类型是struct，他进行了一次copy
　　
所以在每个协程中取出来的时候，Mutex都进行了一次copy，Lock的时候不是同一份锁，所以会出现并发map写入。

解决方法1
　　把Node的成员Mutex 改成指针类型，那么在copy的时候，mutex 能保持对同一份进行Lock，代码如下
　　

package main　　

　　
import (
　　&quot;fmt&quot;
　　&quot;strconv&quot;
　　&quot;sync&quot;
　　
)
　　

　　
type Node struct {
　　*sync.Mutex
　　Data map[string]string
　　
}
　　

　　
var Cache []Node
　　

　　
func main() {
　　Cache = make([]Node, 2)
　　Cache[0] = Node{Data: make(map[string]string), Mutex: &sync.Mutex{}}
　　Cache[1] = Node{Data: make(map[string]string), Mutex: &sync.Mutex{}}
　　

　　wg := sync.WaitGroup{}
　　for i := 0; i < 10000; i++ {
　　wg.Add(1)
　　go func(index int) {
　　defer wg.Done()
　　j := index % 2
　　node := Cache[j]
　　node.Lock()
　　defer node.Unlock()
　　node.Data[strconv.Itoa(index)] = strconv.Itoa(index)
　　}(i)
　　}
　　wg.Wait()
　　fmt.Println(Cache[0])
　　
}
　　

　　Mutex 改成指针类型即可保证同一份锁。

解决方法2 Cache中存储Node指针
　　Cache中如果是Node指针类型，那么index访问的时候，拿出来是指针的副本，指向的仍然是同一份地址，加锁的时候仍然访问的是同一份资源
　　
代码如下
　　

package main　　

　　
import (
　　&quot;fmt&quot;
　　&quot;strconv&quot;
　　&quot;sync&quot;
　　
)
　　

　　
type Node struct {
　　sync.Mutex
　　Data map[string]string
　　
}
　　

　　
var Cache []*Node
　　

　　
func main() {
　　Cache = make([]*Node, 2)
　　Cache[0] = &Node{Data: make(map[string]string)}
　　Cache[1] = &Node{Data: make(map[string]string)}
　　

　　//fmt.Println(Cache);return;
　　wg := sync.WaitGroup{}
　　for i := 0; i < 10000; i++ {
　　wg.Add(1)
　　go func(index int) {
　　defer wg.Done()
　　j := index % 2
　　node := Cache[j]
　　node.Lock()
　　defer node.Unlock()
　　node.Data[strconv.Itoa(index)] = strconv.Itoa(index)
　　}(i)
　　}
　　wg.Wait()
　　fmt.Println(Cache[0])
　　
}
　　

　　

总结
　　golang 类似于C++，系统提供的赋值都是浅拷贝，如果确认需要对同一份内容进行访问的时候，需要在特定的地方用上指针