6-Go锁和条件变量

前言

• 前面我们为了解决协程同步的问题我们使用了channel，但是GO也提供了传统的同步工具
• 它们都在GO的标准库代码包sync和sync/atomic中
• 什么是锁：就是某个协程（线程）在访问某个资源时先锁住，防止其它协程的访问，等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似，例如：公共卫生间

一、死锁

• 死锁的概念：死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁
• Go中死锁的情况
  • ①.单go程自己死锁
  • ②.go程间channel访问顺序导致死锁
  • ③.多go程，多channel 交叉死锁

1 - 单go程自己死锁

• channel应该在至少2个以上的go程中进行通信；否则死锁

package main

func main() {
	ch := make(chan int)
	ch <- 789  // 执行完后，channel的写端阻塞，后续的代码都不会执行，导致死锁
	num := <-ch
	fmt.Println("num = ", num)
}

2 - go程间channel访问顺序导致死锁

• 使用channel一端读（写）， 要保证另一端写（读）操作，同时有机会执行；否则死锁

package main

func main() {
	ch := make(chan int)
	num := <-ch // 此时主go程已经阻塞，后续代码都不会执行
	fmt.Println("num = ", num)

	go func() {
		ch <- 789
	}()
}

3 - 多go程，多channel交叉死锁

• Ago程，掌握M的同时，尝试拿N； Bgo程，掌握N的同时尝试拿M

package main

func main() {
	ch1 := make(chan int)
	ch2 := make(chan int)
	go func() { // 子
		for {
			select {
			case num := <-ch1:
				ch2 <- num
			}
		}
	}()
	for {
		select {
		case num := <-ch2:
			ch1 <- num
		}
	}
}

二、互斥锁

• 互斥锁概念：互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁
• 互斥锁注意事项
  • 在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题
  • 通常借助defer：锁定后，立即使用defer语句保证互斥锁及时解锁
• 互斥锁的原理：
  • A 、B go程 共同访问共享数据。 由于cpu调度随机，需要对 共享数据访问顺序加以限定（同步）
  • 创建 mutex（互斥锁），访问共享数据之前，加锁，访问结束，解锁
  • 在Ago程加锁期间，B go程加锁会失败——阻塞；直至 A go程 解说mutex，B 从阻塞处。恢复执行

package main

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

var mutex sync.Mutex // 创建一个互斥量，新建的互斥锁状态为0，未加锁；锁只有一把

func printer(str string) {
	mutex.Lock()         // 访问共享数据之前，加锁
	defer mutex.Unlock() // 共享数据访问结束，解锁
	for _, ch := range str {
		fmt.Printf("%c", ch)
		time.Sleep(time.Millisecond * 300)
	}
}

func person1() { // 先
	printer("hello")
}

func person2() { // 后
	printer("world")
}

func main() {
	go person1()
	go person2()
	for {

	}
}

三、读写锁

• 为什么需要读写锁：
  • 互斥锁的本质当一个goroutine访问的时候，其他goroutine都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行
  • 其实，当我们对一个不会变化的数据只做“读”操作的话，是不存在资源竞争的问题的。因为数据是不变的，不管怎么读取，多少goroutine同时读取，都是可以的
  • 所以问题不是出在“读”上，主要是修改，也就是“写”。修改的数据要同步，这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的
  • 因此，衍生出另外一种锁，叫做读写锁
• 读写锁的原理：读写锁可以让多个读操作并发，同时读取，但是对于写操作是完全互斥的。也就是说，当一个goroutine进行写操作的时候，其他goroutine既不能进行读操作，也不能进行写操作；写锁优先级高于读锁
• 读写锁类型：GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法
  • ①.一组是对写操作的锁定和解锁，简称“写锁定”和“写解锁”： func (*RWMutex)Lock()、func (*RWMutex)Unlock()
  • ②.另一组表示对读操作的锁定和解锁，简称为“读锁定”与“读解锁”：func (*RWMutex)RLock()、func (*RWMutex)RUlock()
• 在Go语言中，尽量不要将互斥锁、读写锁与channel混用，会产生隐性死锁（如下的代码，就会导致死锁）

package main

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

var rwMutex sync.RWMutex // 锁只有一把， 2个属性 r w

func readGo(in <-chan int, idx int) {
	for {
		rwMutex.RLock() // 以读模式加锁
		num := <-in
		fmt.Printf("----%dth 读 go程，读出：%d\n", idx, num)
		rwMutex.RUnlock() // 以读模式解锁
	}
}

func writeGo(out chan<- int, idx int) {
	for {
		// 生成随机数
		num := rand.Intn(1000)
		rwMutex.Lock() // 以写模式加锁
		out <- num
		fmt.Printf("%dth 写go程，写入：%d\n", idx, num)
		time.Sleep(time.Millisecond * 300) // 放大实验现象
		rwMutex.Unlock()
	}
}

func main() {
	// 播种随机数种子
	rand.Seed(time.Now().UnixNano())
	ch := make(chan int) // 用于 数据传递的 channel

	for i := 0; i < 5; i++ {
		go readGo(ch, i+1)
	}
	for i := 0; i < 5; i++ {
		go writeGo(ch, i+1)
	}
	for {

	}
}

• 隐性死锁的解决方案：不混用读写锁和channel，要么只使用读写锁，要么只使用channel
• 读写锁-rwlock实现

package main

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

var rwMutex sync.RWMutex // 锁只有一把， 2 个属性 r w

var value int // 定义全局变量，模拟共享数据

func readGo(idx int) {
	for {
		rwMutex.RLock() // 以读模式加锁
		num := value
		fmt.Printf("----%dth 读 go程，读出：%d\n", idx, num)
		rwMutex.RUnlock() // 以读模式解锁
		time.Sleep(time.Second)
	}
}
func writeGo(idx int) {
	for {
		// 生成随机数
		num := rand.Intn(1000)
		rwMutex.Lock() // 以写模式加锁
		value = num
		fmt.Printf("%dth 写go程，写入：%d\n", idx, num)
		time.Sleep(time.Millisecond * 300) // 放大实验现象
		rwMutex.Unlock()
	}
}
func main() {
	// 播种随机数种子
	rand.Seed(time.Now().UnixNano())

	for i := 0; i < 5; i++ { // 5 个 读 go 程
		go readGo(i + 1)
	}
	for i := 0; i < 5; i++ { //
		go writeGo(i + 1)
	}
	for {

	}
}

• 读写锁-channel实现：实际上Go语言设计的时候就希望通过chan替代锁

package main

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

func readGo(in <-chan int, idx int) {
	for {
		num := <-in // 从 channel 中读取数据
		fmt.Printf("----%dth 读 go程，读出：%d\n", idx, num)
		time.Sleep(time.Second)
	}
}
func writeGo(out chan<- int, idx int) {
	for {
		// 生成随机数
		num := rand.Intn(1000)
		out <- num // 写入channel
		fmt.Printf("%dth 写go程，写入：%d\n", idx, num)
		time.Sleep(time.Millisecond * 300) // 放大实验现象
	}
}
func main() {
	// 播种随机数种子
	rand.Seed(time.Now().UnixNano())
	ch := make(chan int)

	for i := 0; i < 5; i++ { // 5 个 读 go 程
		go readGo(ch, i+1)
	}
	for i := 0; i < 5; i++ { //
		go writeGo(ch, i+1)
	}
	for {

	}
}

四、条件变量

1 - 条件变量概念

• 条件变量注意事项：本身不是锁！！！ 但经常与锁结合使用！！
• 条件变量概念：条件变量的作用并不保证在同一时刻仅有一个协程（线程）访问某个共享的数据资源，而是在对应的共享数据的状态发生变化时，通知阻塞在某个条件上的协程（线程）。条件变量不是锁，在并发中不能达到同步的目的，因此条件变量总是与锁一块使用
• 条件变量结构体：GO标准库中的sys.Cond类型代表了条件变量。条件变量要与锁（互斥锁，或者读写锁）一起使用。成员变量L代表与条件变量搭配使用的锁

type Cond struct {
   noCopy noCopy
   // L is held while observing or changing the condition
   L Locker
   notify  notifyList
   checker copyChecker
}

2 - 条件变量常用方法

• *func (c Cond) Wait()
  • a）阻塞等待条件变量满足
  • b）释放已掌握的互斥锁相当于cond.L.Unlock()。 注意：两步为一个原子操作
  • c）当被唤醒，Wait()函数返回时，解除阻塞并重新获取互斥锁。相当于cond.L.Lock()
• func (c *Cond) Signal()：单发通知，给一个正等待（阻塞）在该条件变量上的goroutine（线程）发送通知【一般都使用这个】
• func (c *Cond) Broadcast()：广播通知，给正在等待（阻塞）在该条件变量上的所有goroutine（线程）发送通知【会产生惊群效应】
• 条件变量使用流程
  • ①.创建条件变量： var cond sync.Cond
  • ②.指定条件变量用的锁： cond.L = new(sync.Mutex)
  • ③.给公共区加锁（互斥量）：cond.L.Lock()
  • ④.判断是否到达 阻塞条件（缓冲区满/空）—— for 循环判断：for len(ch) == cap(ch) { cond.Wait() —— 1) 阻塞 2) 解锁 3) 加锁｝
  • ⑤.访问公共区 —— 读、写数据、打印
  • ⑥.解锁条件变量用的锁：cond.L.Unlock()
  • ⑦.唤醒阻塞在条件变量上的对端： signal() Broadcast()

3 - 条件变量实现生产者消费者模型

• 注意判断的时候使用for而不是使用if：for len(out) == 5、for len(in) == 0

package main

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

var cond sync.Cond // 定义全局条件变量

func producer(out chan<- int, idx int) {
	for {
		cond.L.Lock() // 先加锁
		// 判断缓冲区是否满
		for len(out) == 5 {
			cond.Wait() // 挂起当前协程， 等待条件变量满足，被消费者唤醒
		}
		num := rand.Intn(800)
		out <- num
		fmt.Printf("生产者%dth，生产：%d\n", idx, num)
		cond.L.Unlock()                    // 访问公共区结束，并且打印结束，解锁
		cond.Signal()                      // 唤醒阻塞在条件变量上的消费者
		time.Sleep(time.Millisecond * 200) // 生产完休息一会，给其他协程执行机会
	}
}

func consumer(in <-chan int, idx int) {
	for {
		// 先加锁
		cond.L.Lock() // 条件变量对应互斥锁加锁（与生产者是同一个）
		// 判断 缓冲区是否为空
		for len(in) == 0 {
			cond.Wait()
		}
		num := <-in
		fmt.Printf("-----消费者%dth，消费：%d\n", idx, num)
		cond.L.Unlock() // 访问公共区结束后，解锁
		cond.Signal()   // 唤醒阻塞在条件变量上的生产者
		time.Sleep(time.Millisecond * 200)
	}
}

func main() {
	product := make(chan int, 5)
	rand.Seed(time.Now().UnixNano())
	quit := make(chan bool)
	// 指定条件变量 使用的锁
	cond.L = new(sync.Mutex) // 互斥锁，初值0，未加锁状态
	for i := 0; i < 5; i++ {
		go producer(product, i+1) // 生产者
	}
	for i := 0; i < 5; i++ {
		go consumer(product, i+1) // 消费者
	}
	/*	for {
		runtime.GC()
	}*/
	<-quit
}