Go语言并发编程(3)：sync包介绍和使用(上)-Mutex,RWMutex,WaitGroup,sync.Map

一、sync 包简介#

在并发编程中，为了解决竞争条件问题，Go 语言提供了 sync 标准包，它提供了基本的同步原语，例如互斥锁、读写锁等。

sync 包使用建议：

除了 Once 和 WaitGroup 类型之外，大多数类型旨在供低级库程序使用。更高级别的同步最好用 channel 通道和通信来完成。

sync 包中类型：

sync.Mutex 互斥锁
sync.RWMutex 读写锁
sync.WaitGroup 等待组(等待一组 goroutine 完成)
sync.Map 并发 Map
sync.Once 执行一次
sync.Pool 对象池
sync.Cond 条件变量

此外，sync 下还有一个包 atomic，它提供了对数据的原子操作。

另外，Go 的扩展包也提供了信号量这种同步原语：

x/sync/semaphore

二、sync.Mutex 互斥锁#

sync.Mutex 是一个互斥锁，它的作用就是保护临界区，确保同一时间只有一个 Go 协程进入临界区。

什么是临界区？为什么有临界区？

在并发编程中，有一部分程序被并发访问，这个访问可能是多个协程/线程修改这部分程序数据，这样的操作会导致意想不到的结果，为了不让操作导致意外结果，怎么办？就需要把这部分程序保护起来，一次只允许一个协程/线程访问这部分区域。需要被保护的这部分程序区域就叫临界区。

防止多个协程/线程同时进入临界区，修改程序数据。

互斥锁就是一种可以保护临界区资源方式。

互斥锁其实是一种最特殊的信号量，这个"量"只有 0 和 1，所以也叫互斥量。互斥量的值为 0 和 1，用来表示加锁和解锁。互斥锁是一种独占锁，即同一时间只能有一个协程持有锁，其他协程必须等待。

互斥锁使得同一时刻只有一个协程执行某段程序，其他协程等待该协程执行完在抢锁后执行。

如上图所示：g1 用互斥锁保护临界区，g2 在中间尝试获取锁失败，g1 离开临界区释放锁，g2 获取到锁然后进行相应操作，操作完后释放锁离开临界区。

第一次使用后不得复制 Mutex。

互斥锁使用：

互斥锁有两个方法 Lock() 加锁和 Unlock() 解锁，他们是成对出现。当一个协程对资源上锁后，其他协程只能等待该协程解锁之后，才能再次上锁。
它还有一个 TryLock()，go1.18 之后添加的。
- 当一个 goroutine 调用此方法试图获取锁时，如果这把锁没有被其他 goroutine 持有，那么这个 goroutine 获取锁并返回 true；
- 如果这把锁已经被其它 goroutine 持有，或正准备给某个唤醒的 gorouine，那么请求锁的 goroutine 直接返回 false，不会阻塞在方法调用上。

Copy
Lock()
代码段(临界区)
Unlock()

为了防止上锁后忘记释放锁，实际使用中用 defer 来释放锁。

例子：

Copy
package main

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

func main() {
	var a = 0

	var lock sync.Mutex
	for i := 0; i < 100; i++ { // 并发 100 个goroutine
		go func(id int) {
			lock.Lock()
			defer lock.Unlock()
			a += 1
			fmt.Printf("goroutine %d, a=%d\n", id, a)
		}(i)
	}

	time.Sleep(time.Second) //等待1秒， 确保所有的协程执行完
}

三、sync.RWMutex 读写锁#

sync.RWMutex 读写锁，对数据操进加锁进一步细分，针对读操作和写操作分别进行加锁和解锁。

在读写锁下，读操作和读操作之间不互斥，多个写操作是互斥，读操作和写操作也是互斥。

当一个 goroutine 获取读锁之后，其它的 goroutine 此时想获取读锁，那么可以继续获取锁，不用等待解锁；此时想获取写锁，就会阻塞等待直到读解锁；
当一个 goroutine 获取写锁之后，其它的 goroutine 无论是获取读锁还是写锁，都会阻塞等待。

读写锁的好处：

多个读之间不互斥，读锁就可以降低对数据读取加互斥锁的性能损耗。而不像互斥锁那样对所有的数据操作，不管是读还是写，同等对待，都加一把大锁处理。

在读多写少的场景下，更适合用读写锁。

RWMutex 读写锁的方法：

Mutex 的加锁和解锁：Lock() 和 Unlock()

只读加锁和加锁：RLock() 和 RUnlock()

RLock() 加读锁时如果存在写锁，则不能加锁；当只有读锁或无锁时，可以加读锁，且读锁可以加载多个。

RUnlock() 解读锁。没有读锁情况下调用 RUlock() 会导致 panic。

释放锁用 defer 来释放锁

Copy
// 使用 RWMutex 的伪码，当然正式代码不会这样写，会用 defer 释放锁
mutex := sync.RWMutex{}

mutex.Lock()
// 操作的资源
mutex.Unlock()

mutex.RLock()
// 读的资源
mutex.RUlock()

例子：

Copy
package main

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

var sum = 0
var rwMutex sync.RWMutex

func main() {
	// 并发写
	for i := 1; i <= 50; i++ {
		go writeSum()
	}

	// 并发读
	for i := 1; i <= 20; i++ {
		go fmt.Println("readSum: ", readSum())
	}

	time.Sleep(time.Second * 2) // 防止主程序退出，子协程还没运行完
	fmt.Println("end sum: ", sum)
}

func writeSum() {
	rwMutex.Lock()         // 读写锁
	defer rwMutex.Unlock() // 释放锁
	sum += 1
}

func readSum() int {
	rwMutex.RLock()         // 读写锁加读锁
	defer rwMutex.RUnlock() // 释放读锁
	return sum
}

四、sync.WaitGroup 等待组#

sync.WaitGroup，等待一组或多个 goroutine 执行完成。

WaitGroup 内部有一个安全的计数器，它调用 Add(n int) 方法把计数器 +n；使用 Done() 方法，将计数器减 1，Done() 的底层是调用 Add(-1)；调用 Wait() 方法等待所有的 goroutine 执行完，即计数器为 0，Wait() 就返回。

WaitGroup 详细原理，可以看我前面的文章：sync.WaitGroup源码分析。

WaitGroup 里的方法：

Add(n)，设置要等待的子 goroutine 数量，n 表示要等待数量

Done()，子 goroutine 执行完后，计数器减一

Wait()，阻塞等待所有子 goroutine 执行完

例子：

Copy
package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup

	wg.Add(2)

	go func() {
		defer wg.Done()
		fmt.Println("子 goroutine1")
	}()

	go func() {
		defer wg.Done()
		fmt.Println("子 goroutine2")
	}()

	wg.Wait() // 等待所有的子goroutine结束

	fmt.Println("程序运行结束")
}

五、sync.Map 并发Map#

在 Go 语言中，内置数据结构 map 并不是并发安全的，所以官方就出了一个 sync.Map。

希望了解 sync.Map 的原理，可以看这篇文章：深入理解Go语言(05)：sync.map原理分析。

sync.Map 里的常用方法：

go v1.20.1

Store(key, value any)，设置键的值

Load(key any) (value any, ok bool)，获取值

Delete(key any)，根据 key 删除值

LoadAndDelete(key any) (value any, loaded bool)，根据 key 删除值，返回以前的值如果还存在

LoadOrStore(key, value any)(actual any, loaded bool)，先根据 key 查找 value，如果找到则返回原来的值，loaded 为 true；如果没有找到 key 对应的 value 值，则存在 key，value 值并将存储值返回，loaded 为 false

Range(f func(key, value any) bool)，遍历 sync.Map 的元素

更多方法请查看：https://pkg.go.dev/sync#Map

例子：

Copy
package main

import (
	"fmt"
	"sync"
)

func main() {
	var syncmap sync.Map

	syncmap.Store("li", 12)
	syncmap.Store("han", "lu")
	syncmap.Store("mei", 34)

	fmt.Println(syncmap.Load("han"))

	// key 不存在
	val, ok := syncmap.LoadOrStore("lei", "lei")
	fmt.Println(val, ok)
	// key 存在
	val, ok = syncmap.LoadOrStore("han", "cunzai")
	fmt.Println(val, ok)

	syncmap.Delete("mei")

	syncmap.Range(func(k, v any) bool {
		fmt.Println("k-v: ", k, v)
		return true
	})
}