暴力锁
package main
import (
"fmt"
"sync"
"time"
)
/*
Go语言包中的 sync 包提供了两种锁类型：sync.Mutex 和 sync.RWMutex。
Mutex 是最简单的一种锁类型，同时也比较暴力，当一个 goroutine 获得了 Mutex 后，其他 goroutine 就只能乖乖等到这个 goroutine 释放该 Mutex。
RWMutex 相对友好些，是经典的单写多读模型。在读锁占用的情况下，会阻止写，但不阻止读，也就是多个 goroutine 可同时获取读锁（调用 RLock() 方法；
而写锁（调用 Lock() 方法）会阻止任何其他 goroutine（无论读和写）进来，整个锁相当于由该 goroutine 独占。从 RWMutex 的实现看，RWMutex 类型其实组合了 Mutex：
type RWMutex struct {
w sync.Mutex
writerSem uint32
readerSem uint32
readerCount uint32
readerWait uint32
}
对于这两种锁类型，任何一个 Lock() 或 RLock() 均需要保证对应有 Unlock() 或 RUnlock() 调用与之对应，否则可能导致等待该锁的所有 goroutine 处于饥饿状态，甚至可能导致死锁。锁的典型使用模式如下：
*/
var (
//逻辑中使用的某个变量,无论是包级的变量还是结构体成员字段都可以
count int
//与变量对应的使用互斥锁，一般情况下将互斥锁的粒度设置的越小越好，降低 因为共享访问时等待的时间
//一般命名方式 变量名+Guard：表示这个互斥锁用于保护这个变量。
countGuard sync.Mutex
)
func GetCount() int {
//锁定，尝试对countGuard互斥量进行加锁。一旦countGuard发生加锁，如果另外一个goroutine尝试加锁时将会发生阻塞，知道这个countGuard进行解锁
countGuard.Lock()
//在函数退出时解除锁定，使用defer将countGuard的解锁进行延迟，解锁将发生在getCount函数返回时
defer countGuard.Unlock()
time.Sleep(time.Second * 10)
return count
}
func SetCount(c int) {
//在设置 count 值时，同样使用 countGuard 进行加锁、解锁操作，保证修改 count 值的过程是一个原子过程，不会发生并发访问冲突。
countGuard.Lock()
count = c
countGuard.Unlock()
}
func main() {
//可以进行并发安全的设置
SetCount(1)
go fmt.Println(GetCount())
go fmt.Println(GetCount())
go fmt.Println(GetCount())
//可以进行并发安全的获取
fmt.Println(GetCount())
}
改成读写锁
package main
import (
"fmt"
"sync"
"time"
)
var (
count1 int
//从 sync.Mutex 互斥锁改为 sync.RWMutex 读写互斥锁。
countGuard1 sync.RWMutex
)
func getCount() int {
//获取 count 的过程是一个读取 count 数据的过程，适用于读写互斥锁。在这一行，把 countGuard.Lock() 换做 countGuard.RLock()，将读写互斥锁标记为读状态。如果此时另外一个 goroutine 并发访问了 countGuard，同时也调用了 countGuard.RLock() 时，并不会发生阻塞。
countGuard1.RLock()
//与读模式加锁对应的，使用读模式解锁。
defer countGuard1.RUnlock()
time.Sleep(time.Second * 10)
return count1
}
func setCount(c int) {
countGuard1.Lock()
count1 = c
countGuard1.Unlock()
}
func main() {
setCount(2)
go fmt.Println(getCount())
go fmt.Println(getCount())
go fmt.Println(getCount())
fmt.Println(getCount())
}
感觉两种访问方法是都是阻塞，读写锁并没有并发访问
