golang 并发锁的陷阱

错误代码示例

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 (
	"fmt"
	"strconv"
	"sync"
)

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 (
	"fmt"
	"strconv"
	"sync"
)

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++，系统提供的赋值都是浅拷贝，如果确认需要对同一份内容进行访问的时候，需要在特定的地方用上指针