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++，系統提供的賦值都是淺拷貝，如果確認需要對同一份內容進行訪問的時候，需要在特定的地方用上指針