Go语言包中的sync包提供了两种锁,互斥锁(sync.Mutex)和读写锁(sync.RWMutex)
这一篇博文我们只说一下互斥锁。
Mutex是一个互斥锁，可以创建为其他结构体的字段；零值为解锁状态。Mutex类型的锁和线程无关，可以由不同的线程加锁和解锁。
• 它只有两个公开方法：Lock()加锁，unlock()解锁。
• 在同一个协程中加锁后，不能再继续对其加锁，否则会panic。只有在解锁之后才能再次加锁。
• 只允许只有一个读或者写的场景
• 在使用Unlock()解锁前,未使用Lock()加锁，就会引起一个运行错误。
函数原型
func (m *Mutex) Lock()
Lock方法锁住m，如果m已经加锁，则阻塞直到m解锁。
func (m *Mutex) Unlock()
Unlock方法解锁m，如果m未加锁会导致运行时错误。锁和线程无关，可以由不同的线程加锁和解锁。
一个例子理解互斥锁的作用
package main
import (
"fmt"
"sync"
)
var num = 0
func increment(wg *sync.WaitGroup) {
num = num + 1
wg.Done()
}
func main() {
var w sync.WaitGroup
for i := 0; i < 1000; i++ {
w.Add(1)
//开启协程
go increment(&w)
}
w.Wait()
fmt.Println("num =", num)
}
在上述程序中，调用1000个协程来进行num=num+1操作
运行几次的输出分别为
num = 971
num = 944
num = 959
每次运行都没有达到预期的效果，因为多个并发的协程试图访问 num 的值，这时就会发生竞态条件。
现在我们可以对上述程序加上锁，每次只能由一个线程来操作num的值
package main
import (
"fmt"
"sync"
)
var num = 0
func increment(wg *sync.WaitGroup, m *sync.Mutex) {
//互斥锁
m.Lock() //当有线程进去进行加锁
num = num + 1
m.Unlock() //出来后解锁，其他线程才可以进去
wg.Done()
}
var w sync.WaitGroup
var m sync.Mutex
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w, &m)//这里要传引用并不能传值，如果传值，那么每个协程都会得到 Mutex 的一份拷贝，竞态条件还是会发生。
}
w.Wait()
fmt.Println("num =", num)
输出
num = 1000
我们也可以使用缓冲信道来实现互斥锁
func increment2(wg *sync.WaitGroup, b chan bool) {
//自定义互斥锁
b <- true
num = num + 1
<-b
wg.Done()
}
func main() {
var w sync.WaitGroup
ch := make(chan bool,1)
for i := 0; i < 1000; i++ {
w.Add(1)
go increment2(&w, ch)
}
w.Wait()
fmt.Println("num =", num)
}
输出
num = 1000
func main() {
wa := sync.WaitGroup{}
var mu sync.Mutex
fmt.Println("加锁0")
mu.Lock()
fmt.Printf("上锁中0\t")
for i := 1; i < 4; i++ {
wa.Add(1)
go func(i int) {
fmt.Printf("加锁%d\t", i)
mu.Lock()
fmt.Printf("上锁中%d\t", i)
time.Sleep(time.Second * 1)
mu.Unlock()
fmt.Printf("解锁%d\t", i)
wa.Done()
}(i)
}
time.Sleep(time.Second * 5)
mu.Unlock()
fmt.Println("\n解锁0")
wa.Wait()
}
输出为
加锁0
上锁中0 加锁2 加锁3 加锁1 上锁中2
解锁0
解锁2 上锁中3 解锁3 上锁中1 解锁1
