【转】golang sync包互斥锁和读写锁的使用

原文:http://www.361way.com/rwmutex/5984.html

协程依次执行：从寄存器读取 a 的值 -> 然后做加法运算 -> 最后写到寄存器。试想，此时一个协程取出 a 的值 3，正在做加法运算（还未写回寄存器）。同时另一个协程此时去取，取出了同样的

a 的值 3。最终导致的结果是，两个协程产出的结果相同，a 相当于只增加了 1。

所以，锁的概念就是，我正在处理 a（锁定），你们谁都别和我抢，等我处理完了（解锁），你们再处理。这样就实现了，同时处理 a 的协程只有一个，就实现了同步。

注：上面的方法是多协程的，增加runtime.GOMAXPROCS(4) 改为多进程多线程同样会有这样的问题。

——————————————————————————————————————————————————

golang sync包里提供了 Locker接口、互斥锁 Mutex、读写锁 RWMutex用于处理并发过程中可能出现同时两个或多个协程（或线程）读或写同一个变量的情况。

一、为什么需要锁

在并发的情况下，多个线程或协程同时去修改一个变量。使用锁能保证在某一时间点内，只有一个协程或线程修改这一变量，具体我们可以看示例。先看不加锁的程序（会出现多个程序同时读该变量）：

package main
import (
"fmt"
"time"
)
func main() {
var a = 0
for i := 0; i < 1000; i++ {
go func(idx int) {
a += 1
fmt.Println(a)
}(i)
}
time.Sleep(time.Second)
}

从理论上来说，上面的函数是每次递增a的值的，所以理论上应该会有1000个不同的值输出，实际结果呢？

[root@361way test]# go run l1.go |sort|uniq |wc -l
998
[root@361way test]# go run l1.go |sort|uniq |wc -l
1000
[root@361way test]# go run l1.go |sort|uniq |wc -l
998
[root@361way test]# go run l1.go |sort|uniq |wc -l
999

这里运行了4次，获取了三个不一样的结果。如果你有精力，可以将运行的结果逐一对比，在出现wc -l的结果小于1000时，绝对出现了重复值。为什么会现这样的情况？

协程依次执行：从寄存器读取 a 的值 -> 然后做加法运算 -> 最后写到寄存器。试想，此时一个协程取出 a 的值 3，正在做加法运算（还未写回寄存器）。同时另一个协程此时去取，取出了同样的 a 的值 3。最终导致的结果是，两个协程产出的结果相同，a 相当于只增加了 1。

注：上面的方法是多协程的，增加runtime.GOMAXPROCS(4) 改为多进程多线程同样会有这样的问题。

二、互斥锁 Mutex

上面的示例中出现的问题怎么解决？加一个互斥锁 Mutex就OK了。哪什么是互斥锁？其有两个方法可以调用，如下：

func (m *Mutex) Lock()
func (m *Mutex) Unlock()

我们改下循环递增示例中的代码，如下：

package main
import (
"fmt"
"time"
)
func main() {
var a = 0
var lock sync.Mutex
for i := 0; i < 1000; i++ {
go func(idx int) {
lock.Lock()
defer lock.Unlock()
a += 1
fmt.Printf("goroutine %d, a=%d ", idx, a)
}(i)
}
// 等待 1s 结束主程序
// 确保所有协程执行完
time.Sleep(time.Second)
}

修改后执行的结果总是1000个不重服的值。而且使用go语言的lock锁一般不会出现忘了解锁的情况，因类其紧跟锁定的就是defer Unlock 。

需要注意的是一个互斥锁只能同时被一个 goroutine 锁定，其它 goroutine 将阻塞直到互斥锁被解锁（重新争抢对互斥锁的锁定）。看如下代码：

package main
import (
"fmt"
"sync"
"time"
)
func main() {
ch := make(chan struct{}, 2)
var l sync.Mutex
go func() {
l.Lock()
defer l.Unlock()
fmt.Println("goroutine1: 我会锁定大概 2s")
time.Sleep(time.Second * 2)
fmt.Println("goroutine1: 我解锁了，你们去抢吧")
ch <- struct{}{}
}()
go func() {
fmt.Println("groutine2: 等待解锁")
l.Lock()
defer l.Unlock()
fmt.Println("goroutine2: 欧耶，我也解锁了")
ch <- struct{}{}
}()
// 等待 goroutine 执行结束
for i := 0; i < 2; i++ {
<-ch
}
}

上面的代码执行结果如下：

[root@361way test]# go run l2.go
goroutine1: 我会锁定大概 2s
groutine2: 等待解锁
goroutine1: 我解锁了，你们去抢吧
goroutine2: 欧耶，我也解锁了

三、读写锁

读写锁有如下四个方法：

写操作的锁定和解锁
* func (*RWMutex) Lock
* func (*RWMutex) Unlock
读操作的锁定和解锁
* func (*RWMutex) Rlock
* func (*RWMutex) RUnlock

注：区别在后的Lock和Unlock前有没有R 。

我们怎么理解读写锁呢？当有一个 goroutine 获得写锁定，其它无论是读锁定还是写锁定都将阻塞直到写解锁；当有一个 goroutine 获得读锁定，其它读锁定仍然可以继续；当有一个或任意多个读锁定，写锁定将等待所有读锁定解锁之后才能够进行写锁定。所以说这里的读锁定（RLock）目的其实是告诉写锁定：有很多人正在读取数据，你给我站一边去，等它们读（读解锁）完你再来写（写锁定）。我们可以将其总结为如下三条：

同时只能有一个 goroutine 能够获得写锁定。
同时可以有任意多个 gorouinte 获得读锁定。
同时只能存在写锁定或读锁定（读和写互斥）。

看个示例：

package main
import (
"fmt"
"math/rand"
"sync"
)
var count int
var rw sync.RWMutex
func main() {
ch := make(chan struct{}, 10)
for i := 0; i < 5; i++ {
go read(i, ch)
}
for i := 0; i < 5; i++ {
go write(i, ch)
}
for i := 0; i < 10; i++ {
<-ch
}
}
func read(n int, ch chan struct{}) {
rw.RLock()
fmt.Printf("goroutine %d 进入读操作... ", n)
v := count
fmt.Printf("goroutine %d 读取结束，值为：%d ", n, v)
rw.RUnlock()
ch <- struct{}{}
}
func write(n int, ch chan struct{}) {
rw.Lock()
fmt.Printf("goroutine %d 进入写操作... ", n)
v := rand.Intn(1000)
count = v
fmt.Printf("goroutine %d 写入结束，新值为：%d ", n, v)
rw.Unlock()
ch <- struct{}{}
}

其执行结果如下：

[root@361way test]# go run l3.go
goroutine 4 进入写操作...
goroutine 4 写入结束，新值为：81
goroutine 2 进入读操作...
goroutine 2 读取结束，值为：81
goroutine 3 进入读操作...
goroutine 3 读取结束，值为：81
goroutine 0 进入读操作...
goroutine 0 读取结束，值为：81
goroutine 1 进入读操作...
goroutine 4 进入读操作...
goroutine 4 读取结束，值为：81
goroutine 1 读取结束，值为：81
goroutine 0 进入写操作...
goroutine 0 写入结束，新值为：887
goroutine 1 进入写操作...
goroutine 1 写入结束，新值为：847
goroutine 3 进入写操作...
goroutine 3 写入结束，新值为：59
goroutine 2 进入写操作...
goroutine 2 写入结束，新值为：81

再来看两个例子：

package main
import (
"sync"
"time"
)
var m *sync.RWMutex
func main() {
m = new(sync.RWMutex)
// 多个同时读
go read(1)
go read(2)
time.Sleep(2*time.Second)
}
func read(i int) {
println(i,"read start")
m.RLock()
println(i,"reading")
time.Sleep(1*time.Second)
m.RUnlock()
println(i,"read over")
}

这里例子中，多个读操作同时读一个操作。虽然加了锁，但都是读是不受影响的。（读和写是互斥的，读和读不互斥----我靠，这是同性才是真爱的节奏啊）。

package main
import (
"sync"
"time"
)
var m *sync.RWMutex
func main() {
m = new(sync.RWMutex)
// 写的时候啥也不能干
go write(1)
go read(2)
go write(3)
time.Sleep(2*time.Second)
}
func read(i int) {
println(i,"read start")
m.RLock()
println(i,"reading")
time.Sleep(1*time.Second)
m.RUnlock()
println(i,"read over")
}
func write(i int) {
println(i,"write start")
m.Lock()
println(i,"writing")
time.Sleep(1*time.Second)
m.Unlock()
println(i,"write over")
}

由于读写互斥，上面这个示例中，写开始的时候，读必须要等写进行完才能继续。不然他只能继续等待，这就像只有一个茅坑，别我蹲着，你着急也不能去抢（为什么？有门关着呢！）。