Go语言互斥锁（sync.Mutex）和读写互斥锁（sync.RWMutex）

暴力锁

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())
}

感觉两种访问方法是都是阻塞，读写锁并没有并发访问