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

}

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

巴特西

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

最新文章

热门文章