Go语言标准库学习之sync一（go语言中的锁）

在go语言多线程编程的过程中，我们会遇到多线程进行资源读写的问题，在GO语言中我们可以使用channel进行控制，但是除了channel我们还可以通过sync库进行资源的读写控制，这也就是我们常说的锁。锁的作用就是某个协程（线程）在访问某个资源时先锁住，防止其它协程的访问，等访问完毕解锁后其他协程再来加锁进行访问。本文向记录了学习sync标准库的学习笔记，希望对你有帮助。

一、互斥锁

1.什么是互斥锁

这里摘录百度百科的解释：

互斥锁是用来保证共享数据操作的完整性的。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。

2.sync.Mutex

在sync库中Mutex对象实现了两个方法，Lock和UnLock，从字面意思就可以理解，一个是锁另一个是释放锁。

// A Mutex is a mutual exclusion lock.
// The zero value for a Mutex is an unlocked mutex.
//
// A Mutex must not be copied after first use.
type Mutex struct {
	state int32
	sema  uint32
}

在源码定义中我们可以看出，Mutex在使用后不能被复制，因此这里我们要注意。

3.互斥锁的使用

接下来我们看一下如何使用Mutex进行资源锁定和释放。

package main

import (
	"fmt"
	"sync"
	"time"
)

// 定义一个锁
var m = new(sync.Mutex)

func StdOut(s string) {
	// 创建一个互斥锁
	//m := new(sync.Mutex)
	m.Lock()
	// 当main函数执行完成后，释放锁
	defer m.Unlock()
	for _, data := range s {
		fmt.Printf("%c", data)
	}
	fmt.Println()
}

func Person1(s string) {
	StdOut(s)
}

func main() {
	go Person1("Random_w1")
	go Person1("Random_w2")
	Person1("Random_w3")
	// 等待两秒，让goroutine运行完成
	time.Sleep(time.Millisecond * 100)
}

Output:

$ go run main.go
Random_w3
Random_w1
Random_w2

如果将StdOut中的Lock删除掉，那么输出就会混乱：

$ go run main.go
RandomRandom_w1
Random_w2
_w3

通过比对两种情况大家应该理解了互斥锁的使用了。

二、读写锁

1.什么是读写锁

同样这里我引用百度百科的解释：

读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作。

互斥锁的本质是当一个goroutine访问的时候，其他goroutine都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。

2. sync.RWMutex

type RWMutex struct {
	w           Mutex  // held if there are pending writers
	writerSem   uint32 // semaphore for writers to wait for completing readers
	readerSem   uint32 // semaphore for readers to wait for completing writers
	readerCount int32  // number of pending readers
	readerWait  int32  // number of departing readers
}

sync.RWMutex 结构体实现了五种方法：

func (rw *RWMutex) Lock() 写锁定
func (rw *RWMutex) UnLock() 写解锁
func (rw *RWMutex) RLock() 读锁定
func (rw *RWMutex) RUnLock() 读解锁
func (rw *RWMutex) RLocker() Locker

RWMutex的使用主要事项

读锁的时候无需等待读锁的结束
读锁的时候要等待写锁的结束
写锁的时候要等待读锁的结束
写锁的时候要等待写锁的结束

3. 读写锁的使用

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

// 定义一个锁
var m = new(sync.RWMutex)
var count int

// Write 对count进行写操作
func Write(n int) {
	rand.Seed(time.Now().UnixNano())
	fmt.Printf("写 goroutine %d 正在写数据...\n", n)
	m.Lock()
	num := rand.Intn(500)
	count = num
	fmt.Printf("写 goroutine %d 写数据结束，写入新值 %d\n", n, num)
	m.Unlock()
}
// Read 对count进行读操作
func Read(n int) {
	m.RLock()
	fmt.Printf("读 goroutine %d 正在读取数据...\n", n)
	num := count
	fmt.Printf("读 goroutine %d 读取数据结束，读到 %d\n", n, num)
	m.RUnlock()
}

func main() {
	// 创建goroutine，进行读写操作
	for i := 0; i < 3; i++ {
		go Read(i)
		go Write(i)
	}
	time.Sleep(time.Second)
}

Output:

$ go run main.go
读 goroutine 1 正在读取数据...
读 goroutine 1 读取数据结束，读到 0
读 goroutine 0 正在读取数据...
读 goroutine 0 读取数据结束，读到 0
写 goroutine 2 正在写数据...
写 goroutine 0 正在写数据...
写 goroutine 1 正在写数据...
读 goroutine 2 正在读取数据...
读 goroutine 2 读取数据结束，读到 0
写 goroutine 2 写数据结束，写入新值 337
写 goroutine 0 写数据结束，写入新值 16
写 goroutine 1 写数据结束，写入新值 134

从Output中我们可以看到，当读锁被锁定时，写锁时阻塞状态，只有当读锁解除后，count才能写入新值。

三、Cond的使用

Cond是一个比较冷门的结构体，sync.Cond用于goroutine之间的协作，用于协程的挂起和唤醒。

1. Cond结构体

从下面的结构体我么可以看出Cond在被创建后是不能复制的，和互斥锁类似。

// A Cond must not be copied after first use.
type Cond struct {
	noCopy noCopy  // noCopy可以嵌入到结构中，在第一次使用后不可复制,使用go vet作为检测使用
 
	L Locker // 根据需求初始化不同的锁，如*Mutex 和 *RWMutex
 
	notify  notifyList  // 通知列表,调用Wait()方法的goroutine会被放入list中,每次唤醒,从这里取出
	checker copyChecker // 复制检查,检查cond实例是否被复制
}

2. Cond结构体实现的方法

Cond结构体实现了四个方法，分别是：

func (c *Cond) Wait() 必须获取该锁之后才能调用Wait()方法，Wait方法在调用时会释放底层锁Locker，并且将当前goroutine挂起，直到另一个goroutine执行Signal或者Broadcase，该goroutine才有机会重新唤醒，并尝试获取Locker，完成后续逻辑。也就是在等待被唤醒的过程中是不占用锁Locker的，这样就可以有多个goroutine可以同时处于Wait(等待被唤醒的状态)
func (c *Cond) Signal() 唤醒等待队列中的一个goroutine，一般都是任意唤醒队列中的一个goroutine。
func (c *Cond) Broadcast()唤醒等待队列中的所有goroutine。
func NewCond(l Locker) *Cond ，使用Locker创建一个Cond对象。

3. Cond的使用

下面的示例代码中我们使用cond.Wait让goroutine进入等待状态，在main函数中，我们分别测试了使用Siginal和Broadcast将goroutine唤醒，为了表示Siginal一次只能唤醒一个goroutine因此加入了时间，正常情况下实例中的goroutine在不到一微秒的时间就可以执行完成，但是我们延时了一秒，除了被唤醒的goroutine运行外，其他goroutine并没有执行。使用Broadcast我们可以看到剩下的两个goroutine快速执行完成。

package main

import (
	"fmt"
	"sync"
	"time"
)

// 定义一个锁
var mutex = new(sync.Mutex)
// 初始化一个cond
var cond = sync.NewCond(mutex)

func CondTest() {
	// 5个goroutine正常情况下一微秒时间都可以运行完
	for i := 0; i < 5; i++ {
		id := i
		go func() {
			mutex.Lock()
			defer mutex.Unlock()
			// 让所有goroutine等待
			cond.Wait()
			fmt.Printf("goroutine %d 运行完成\n", id)
		}()
	}
}
// 输出时间
func PrintTime() {
	fmt.Println(time.Now().Format("15:04:05"))
}
func main() {
	CondTest()
	// 运行三个goroutine
	for i := 0; i < 3; i++ {
		PrintTime()
		cond.Signal()
		time.Sleep(time.Second)
	}
	// 通过Broadcast唤醒所有的goroutine
	PrintTime()
	cond.Broadcast()
	time.Sleep(time.Millisecond)
}

Output:

$ go run main.go
14:40:29
goroutine 1 运行完成
14:40:30
goroutine 0 运行完成
14:40:31
goroutine 2 运行完成
14:40:32
goroutine 4 运行完成
goroutine 3 运行完成

四、更优雅的等待goroutine结束（sync.WaitGroup）

平时我们在测试或者创建goroutine后，往往通过延时的方式等待goroutine退出，这种方式是比较耗费时间的，在sync中我们可以使用WaitGroup的方法更优雅的等待goroutine结束。

1. WaitGroup的使用

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
    // 新建一个WaitGroup对象
	wg := sync.WaitGroup{}
	// WaitGroup的数量为3
	wg.Add(3)
	for i := 0; i < 3; i++ {
		id := i
		go func() {
			fmt.Printf("goroutine %d 运行完成\n", id)
			// goroutine运行完成，通知wg
			wg.Done()
		}()
	}
	//wg程序阻塞，等待所有goroutine运行完成
	wg.Wait()
}

Output:

$ go run main.go
goroutine 2 运行完成
goroutine 0 运行完成
goroutine 1 运行完成

2. WaitGroup的注意事项

我们不能使用Add() 给wg 设置一个负值，否则代码将会报错。

$ go run main.go
panic: sync: negative WaitGroup counter

goroutine 1 [running]:
sync.(*WaitGroup).Add(0xc000070070, 0xffffffffffffffff)
        c:/Go/src/sync/waitgroup.go:74 +0x13c
main.main()
        D:/GOCODE/Test/main.go:12 +0x54
exit status 2

WaitGroup对象不是一个引用类型，在通过函数传值的时候需要使用地址。

package main

import (
   "fmt"
   "math/rand"
   "sync"
   "time"
)

func main() {
   wg := sync.WaitGroup{}
   wg.Add(3)
   for i := 0; i < 3; i++ {
   	id := i
   	go func(wg *sync.WaitGroup) {
   		fmt.Printf("goroutine %d 运行完成\n", id)
   		wg.Done()
   	}(&wg)
   }
   wg.Wait()
}

Output:

$ go run main.go
goroutine 2 运行完成
goroutine 0 运行完成
goroutine 1 运行完成

上面的main函数如果改成这样：

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

func main() {
	wg := sync.WaitGroup{}
	wg.Add(3)
	for i := 0; i < 3; i++ {
		id := i
		go func(wg sync.WaitGroup) {
			fmt.Printf("goroutine %d 运行完成\n", id)
			wg.Done()
		}(wg)
	}
	wg.Wait()
}

Output:

$ go run main.go
goroutine 2 运行完成
goroutine 0 运行完成
goroutine 1 运行完成
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [semacquire]:
sync.runtime_Semacquire(0xc000070078)
        c:/Go/src/runtime/sema.go:56 +0x40
sync.(*WaitGroup).Wait(0xc000070070)
        c:/Go/src/sync/waitgroup.go:130 +0x6c
main.main()
        D:/GOCODE/Test/main.go:20 +0xbc
exit status 2

可以看到，不使用地址传递参数会在goroutine运行完成之后触发panic报错。

Go语言标准库学习之sync一（go语言中的锁）

一、互斥锁

1.什么是互斥锁

2.sync.Mutex

3.互斥锁的使用

二、读写锁

1.什么是读写锁

2. sync.RWMutex

3. 读写锁的使用

三、Cond的使用

1. Cond结构体

2. Cond结构体实现的方法

3. Cond的使用

四、更优雅的等待goroutine结束（sync.WaitGroup）

1. WaitGroup的使用

2. WaitGroup的注意事项

[软件工具百科] 互联网资源历史快照归档站点与数字图书馆

网易面试：SpringBoot如何开启虚拟线程？

杭州的 IT 崩盘了么？

程序员常见的文本查看工具

VS2022 解决方案打不开 .NET Framework 4.0 、 4.5 等老项目

Vue3 运行可以，build 打包发布报错，app.config.globalProperties 用法坑

既然测试也要求写代码，那干脆让开发兼任测试不就好了吗？

ITSM落地经验之建设蓝图规划

PDF 补丁丁 1.0.2 版更新

奇怪！应用的日志呢？？

Go語言中的html/template標準庫學習筆記一（template庫的使用）

Go語言標準庫學習之sync一（go語言中的鎖）

Shell編程從入門到精通——基本文本處理（一）

Go語言cobra庫學習筆記——從入門到精通

Go語言中的html/template標準庫學習筆記二（template語法介紹）

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結