golang中的锁
在golang中，goroutine 可以理解为其它语言中的线程，在其它语言中存在的数据竞态的问题，在golang中同样存在
本文记录一下数据竞态与各种锁的使用
race condition 竞争状态
这个词也没有听起来很高大上，其实并没有什么新鲜的东西，就是多个协程对同一个变量进行读写，造成了状态不一致，得不到正确的结果，我们来看一下代码
package main
import (
"fmt"
"sync"
)
var data int
func incr(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 10000; i++ {
data = data + 1
}
}
func main() {
wg := sync.WaitGroup{}
wg.Add(2)
go incr(&wg)
go incr(&wg)
wg.Wait()
fmt.Println(data)
}
有一个函数，对全局的变量data 进行加10000操作，如果有两个这样的协程同时进行操作，我们希望得到的结果是20000， 可是上面的结果并不会得到20000，而且每次的结果都不太一样，更像是一些随机的数。 两个协程同时操作data变量，这两个协程产生了竞争状态，这就产生了race conditiion。 go 为我们提供了竞态检查命令, go build -race main.go , 这时再运行打包出来的程序，如果有竞态，则会打印出具体的代码位置
==================
WARNING: DATA RACE
Read at 0x000001200788 by goroutine 8:
main.incr()
golock/main.go:14 +0x95
main.main·dwrap·3()
golock/main.go:22 +0x39
Previous write at 0x000001200788 by goroutine 7:
main.incr()
golock/main.go:14 +0xad
main.main·dwrap·2()
golock/main.go:21 +0x39
Goroutine 8 (running) created at:
main.main()
golock/main.go:22 +0x138
Goroutine 7 (finished) created at:
main.main()
golock/main.go:21 +0xd0
==================
20000
Found 1 data race(s)
在源码中的14，21，22行存在竞态
data = data + 1 // 14行
go incr(&wg) // 21行
go incr(&wg) // 22行
该如何避免竞态呢？ 可以使用以下几种方式
使用原子性操作
加入互斥锁
使用channel
使用原子性操作
上面的问题主要产生于 data = data + 1 这个操作不是原子性的，程序是先取出data的值，比如5，这时候如果系统调度到了别的协程，则另外一个协程也会拿到相同的data值，之后再将data 值加1，但是两个协程都在原来值上加1，就是6，也要造成了虽然执行了两次，但是值只加了1
golang的atomic 中提供了一些能用的方法，如对int32类型的值做加操作, 将上面的incr函数修改一下
func incr(wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 10000; i++ {
atomic.AddInt32(&data, 1)
}
}
此时就不再有竞态了，且每次都会得到20000的结果。
使用锁
atomic 包中提供的函数比较单一，对于上面的需求可以很好的满足，但是通常情况下，我们的处理逻辑不会这么简单，这时我们就需要使用锁来保证读写的原子性了.
锁使用比较多的是互斥锁，读写锁
互斥锁，这种锁和其它语言的互斥锁是一样的，谁获取到了锁就有执行权，没有获取到的就只能等着了
package main
import (
"fmt"
"sync"
)
var data int32
func incr(wg *sync.WaitGroup, lock *sync.Mutex) {
defer wg.Done()
lock.Lock()
for i := 0; i < 10000; i++ {
data = data + 1
}
lock.Unlock()
}
func main() {
wg := sync.WaitGroup{}
lock := sync.Mutex{}
wg.Add(2)
go incr(&wg, &lock)
go incr(&wg, &lock)
wg.Wait()
fmt.Println(data)
}
上面代码在对for 循环加1操作进行的加锁，结束之后释放掉锁。
注意的问题，如果锁作为参数传递到函数中，需要使用指针形式，如上面的 func incr(wg *sync.WaitGroup, lock *sync.Mutex), 如果传递的是值，则起不到加锁的功能。
当我们定义一个结构体，有用到Mutex 匿名字段的时候， 在声明结构体方法时，也需要使用指针形式
type mylock struct {
sync.Mutex
}
func (m *mylock) test() {
m.Lock()
for i := 0; i < 10000; i++ {
data = data + 1
}
}
如果声明结构体方法为 func (m mylock) test() 时，则使用 m.Lock()并不会起到加锁的效果。
锁的范围
上面的代码中，我们是将整体for 循环锁住了，但其实我们更应该将锁的颗粒度减小
func incr(wg *sync.WaitGroup, lock *sync.Mutex) {
defer wg.Done()
for i := 0; i < 10000; i++ {
lock.Lock()
data = data + 1
lock.Unlock()
}
}
锁不支持递归获取
java 中有可重入锁，但是在 golang 中不存在， 即使在同一个协程中也不行
func (m *mylock) test() {
m.Lock()
m.Lock()
......
m.Unlock()
m.Unlock()
}
当然你不太可能傻傻的写出上面的代码，但是下面的写法可能会不小心发生
type mylock struct {
sync.Mutex
}
func (m *mylock) test() {
m.Lock()
m.test2()
m.Unlock()
}
func (m *mylock) test2() {
m.Lock()
fmt.Println("in test2")
m.Unlock()
}
var ml mylock = mylock{}
ml.test()
此时，调用ml的test方法，这个方法要进行加锁，然后test方法又调用test2方法，这个方法也要获取锁，这种情况下也会造成死锁。
读写锁 RWMutex
互斥锁使用起来比较方便，但是有一个问题就是，它锁权利太大了，同时只能有一个协程能操作数据，但是我们想一个问题，如果一个变量，多个协程只是读它的数据，并没有写的操作，此时对于多个协程同时读是不会造成竞态的。此时如果我们还是使用互斥锁的话，在效率上难免会受到一些影响。
package main
import (
"fmt"
"sync"
"time"
)
var data int = 10
func readata(id int, lock *sync.Mutex, wg *sync.WaitGroup) {
lock.Lock()
fmt.Printf("goroutine %d get lock, data is %d \n", id, data)
time.Sleep(1 * time.Second)
lock.Unlock()
wg.Done()
}
func main() {
var lock *sync.Mutex = new(sync.Mutex)
var wg sync.WaitGroup
start := time.Now()
wg.Add(5)
for i := 0; i < 5; i++ {
go readata(i, lock, &wg)
}
wg.Wait()
used := time.Since(start).Seconds()
fmt.Printf("Use %f second \n", used)
}
上面的代码，起了5个协程，每个协程，每个协程都尝试去读data 的值 ，并没有写的操作，每个协程耗时1秒钟，在互斥锁的加持下，同时只能有一个协程得到运行，这时总的耗时大概就是5秒钟
➜ golock go run main.go goroutine 4 get lock, data is 10 goroutine 1 get lock, data is 10 goroutine 0 get lock, data is 10 goroutine 2 get lock, data is 10 goroutine 3 get lock, data is 10 Use 5.018138 second
这时我们就可以使用读锁来取带互斥锁，读锁可以让5个协程同时读
package main
import (
"fmt"
"sync"
"time"
)
var data int = 10
func readata(id int, lock *sync.RWMutex, wg *sync.WaitGroup) {
lock.RLock() // 修改点 1
fmt.Printf("goroutine %d get lock, data is %d \n", id, data)
time.Sleep(1 * time.Second)
lock.RUnlock() // 修改点 2
wg.Done()
}
func main() {
var lock *sync.RWMutex = new(sync.RWMutex) // 修改点3
var wg sync.WaitGroup
start := time.Now()
wg.Add(5)
for i := 0; i < 5; i++ {
go readata(i, lock, &wg)
}
wg.Wait()
used := time.Since(start).Seconds()
fmt.Printf("Use %f second \n", used)
}
上面主要修改三处，修改点1和修改点2 使用RLock和RUnlock进行加锁和解锁，注意这里的锁是sync.RWMutex指针变量。 修改点3 为lock 对象的初始化，之前的sync.Mutex，这里是sync.RWMutex
这时5个协程就可以同时的进行读取操作了
➜ golock go run main.go goroutine 1 get lock, data is 10 goroutine 4 get lock, data is 10 goroutine 0 get lock, data is 10 goroutine 2 get lock, data is 10 goroutine 3 get lock, data is 10 Use 1.003802 second
这种情况下，有人会问了，这样加锁和不加锁效果不是一样的吗？ 我不加锁也同样可以5个协程同时读取变量呀！
是的，对于上面的场景确实加不加读锁都一样的，没有涉及到写的操作，只有读也不会产生race condition, 但是想一个问题，此时，如果有一个协程需要对变量进行写操作了，那么这时候问题就变得复杂了。 我们可以想象有以下几个场景
某个协程正在读该数据
某个协程正要准备写数据
读锁和写锁调用加锁的方法是不一样的，对于第一种情况，当某个协程正在读数据的时候，写锁是得不到的，对于第二种情况，当某个协程获取到了写锁，那么所有想要获取读锁的协程也是获取不到锁的，我们来写个程序验证一下。
package main
import (
"fmt"
"sync"
"time"
)
var data int = 10
func readata(id int, lock *sync.RWMutex, wg *sync.WaitGroup) {
lock.RLock()
fmt.Printf("goroutine %d get lock, data is %d \n", id, data)
time.Sleep(1 * time.Second)
lock.RUnlock()
wg.Done()
}
func setdata(id int, lock *sync.RWMutex, wg *sync.WaitGroup) {
defer wg.Done()
lock.Lock() // 关键处 1
data = data + 1
fmt.Printf("goroutine %d get wlock, set data %d \n", id, data)
time.Sleep(1 * time.Second)
lock.Unlock()
}
func main() {
var lock *sync.RWMutex = new(sync.RWMutex)
var wg sync.WaitGroup
start := time.Now()
wg.Add(8)
for i := 0; i < 4; i++ {
go readata(i, lock, &wg)
}
for i := 0; i < 4; i++ {
go setdata(i, lock, &wg)
}
wg.Wait()
used := time.Since(start).Seconds()
fmt.Printf("Use %f second \n", used)
}
我们写了个setdata 函数，这个函数的参数，是一个读写锁，但是在函数体内，在关键处1 我们使用lock.Lock()来获取写锁。之后起了8个协程，其中有4个协程进行读，4个协程进行写，但是这段代码的运行结果就比较有意思了。
➜ golock go run main.go goroutine 0 get lock, data is 10 goroutine 3 get lock, data is 10 goroutine 3 get wlock, set data 11 goroutine 1 get lock, data is 11 goroutine 2 get lock, data is 11 goroutine 0 get wlock, set data 12 goroutine 1 get wlock, set data 13 goroutine 2 get wlock, set data 14 Use 6.023362 second ➜ golock go run main.go goroutine 3 get wlock, set data 11 goroutine 1 get lock, data is 11 goroutine 3 get lock, data is 11 goroutine 0 get lock, data is 11 goroutine 2 get lock, data is 11 goroutine 1 get wlock, set data 12 goroutine 0 get wlock, set data 13 goroutine 2 get wlock, set data 14 Use 5.015582 second
我多次运行，总的耗时是不确认的，我们来分析一下, 先看第一次运行结果 goroutine 0 get lock, data is 10 goroutine 3 get lock, data is 10 先由goroutine 0 和 3 这两个协程获取到读锁，然后打印出data的结果10，这时耗时1秒，总时间1秒
然后写协程获取到写锁，读data设置为11 goroutine 3 get wlock, set data 11 这里只能有一个写协程获取到写锁，这时又耗时1秒，总时间2秒。 之后又有两个读协程获取到读锁 ，读到的data值已经变为了11 goroutine 1 get lock, data is 11 goroutine 2 get lock, data is 11
这时又耗时1秒，总时间3秒， 这时读协程已经运行完毕。 goroutine 0 get wlock, set data 12 goroutine 1 get wlock, set data 13 goroutine 2 get wlock, set data 14 之后就是三个写协程分别单独获取到写锁，并分别耗时1秒，总的时间是6秒。
第二次运行的结果 goroutine 3 get wlock, set data 11 写协程3 获取写锁，耗时1秒， 总耗时1秒 goroutine 1 get lock, data is 11 goroutine 3 get lock, data is 11 goroutine 0 get lock, data is 11 goroutine 2 get lock, data is 11 之后四个读协程同时获取到读锁，耗时1秒，总耗时2秒 goroutine 1 get wlock, set data 12 goroutine 0 get wlock, set data 13 goroutine 2 get wlock, set data 14 三个写协程分别获取到写锁，各耗时1秒，总耗时5秒。
上面的程序如果使用互斥锁的话，那么8个协程运行下来，总的耗时是在8秒钟左右，使用读写锁来优化以后，程序最短需要5秒，最坏的情况下也是8秒。 有了读写锁，会使程序既保证了数据的准确性，又提高了运行效率。 对于读多写少的协程间操作，我们可以使用读写锁来优化，
sync.Map
golang 原生的map 是不支持并发的
func readmap(m map[int]int, wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 1000; i++ {
fmt.Println(m[i])
}
}
func setmap(m map[int]int, wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 1000; i++ {
m[i] = i
}
}
func main() {
var wg sync.WaitGroup
var m map[int]int = make(map[int]int)
wg.Add(2)
go readmap(m, &wg)
go setmap(m, &wg)
wg.Wait()
fmt.Println("main over")
}
这里有两个协程，一个写，一个读，这时运行程序就会报fatal error: concurrent map read and map write 解决办法也简单，加上锁就可以, 但是golang 为我们提供了一个sync.Map的结构体，这是线程安全的map，我们可以在有多个协程操作map的时候使用该结构
func readmap(m *sync.Map, wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 10; i++ {
fmt.Println(m.Load(i))
}
}
func setmap(m *sync.Map, wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 10; i++ {
m.Store(i, i)
}
}
func main() {
var wg sync.WaitGroup
var m sync.Map
wg.Add(2)
go setmap(&m, &wg)
go readmap(&m, &wg)
wg.Wait()
fmt.Println("main over")
}
sync.Map 结构体主要有以下几个方法 func (m *Map) Load(key interface{}) (value interface{}, ok bool) 从sync.Map中取值 func (m *Map) Store(key, value interface{})向一个sync.Map设置值 func (m *Map) Delete(key interface{})删除sync.Map 中的的某个键 func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) 从sync.Map中取出某个值，并从sync.Map中删除掉该键 func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) 读取或者设置某个键值，如果该键存在，则返回该值，如果不存在，会先设置该键值，并且将value返回
sync.Map 适合那种读出写少的场景，以下这篇文章详细的对原生map+互斥锁，原生map+读写锁, sync.Map 之间的性能做了对比，得出的结论就是读多写少的场景，会更建议使用 sync.Map 类型
