go语言 互斥锁 读写锁

互斥锁

每个资源都对应于一个可称为 "互斥锁" 的标记，这个标记用来保证在任意时刻，只能有一个协程（线程）访问该资源。其它的协程只能等待。

互斥锁是传统并发编程对共享资源进行访问控制的主要手段，它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法，Lock和Unlock。Lock锁定当前的共享资源，Unlock进行解锁。

在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer语句保证互斥锁及时解锁。

var mt sync.Mutex
mt.Lock()    // 加锁
...         // 共享资源
mt.Unlock()  // 解锁

package main

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

var mt sync.Mutex
func test(str string)  {
    mt.Lock()
	for _, s := range str{
		//fmt.Println(s)  // 打印的是字节
		fmt.Printf("%c",s)
		time.Sleep(time.Millisecond * 100)
	}
    mt.Unlock()
}

func foo(str string)  {
	test(str)
}

func fun(str string)  {
	test(str)
}

func main() {
	go foo("hello")
	go fun("world")

	for {
		;
	}
}

读写锁

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

当我们对一个不会变化的数据只做“读”操作的话，是不存在资源竞争的问题的,因为读不会对数据进行更改,问题不是出在“读”上，主要是修改，也就是“写”。修改的数据要同步，这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。

因此，衍生出另外一种锁，叫做读写锁。

读写锁可以让多个读操作并发，同时读取，但是对于写操作是完全互斥的。也就是说，当一个goroutine进行写操作的时候，其他goroutine既不能进行读操作，也不能进行写操作。

GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法：

一组是对写操作的锁定和解锁，简称“写锁定”和“写解锁”：

func (*RWMutex)Lock()

func (*RWMutex)Unlock()

另一组表示对读操作的锁定和解锁，简称为“读锁定”与“读解锁”：

func (*RWMutex)RLock()

func (*RWMutex)RUlock()

案例:

var rwMut sync.RWMutex
var value  int

func readGo(i int)  {
	for{
		rwMut.RLock()  // 加读锁
		num:= value
		fmt.Printf("%d th , read %d \n", i, num)
		rwMut.RUnlock()  // 解读锁
	}
}
func writeGo(i int, qu chan <- int)  {
	for q := 1;q < 500; q++{
		if q == 10{
			qu <- 1
		}
		num := rand.Intn(1000)
		rwMut.Lock()  // 加写锁
		value = num
		fmt.Printf("%d th , write %d \n", i, num)

		time.Sleep(time.Millisecond * 100)
		rwMut.Unlock()  // 解写锁
	}
}


func main() {
	quit := make(chan int)
	rand.Seed(time.Now().UnixNano())
	for i:=1;i < 5 ;i++  {
		go readGo(i+1)
	}

	for i:=1;i < 5 ;i++  {
		go writeGo(i+1, quit)
	}
	<- quit
}

>>> :
3 th , write 466  // 写独占
4 th , read 466   // 读共享
2 th , read 466
3 th , read 466
5 th , read 466
4 th , write 646
4 th , read 646
3 th , read 646
2 th , read 646
5 th , read 646
5 th , write 319
....

条件变量

条件变量的作用并不保证在同一时刻仅有一个协程（线程）访问某个共享的数据资源，而是在对应的共享数据的状态发生变化时，通知阻塞在某个条件上的协程（线程）。条件变量不是锁，在并发中不能达到同步的目的，因此条件变量总是与锁一块使用。

使用

条件变量使用步骤:生产者消费者同样

• 判断条件变量
• 加锁
• 访问共享数据
• 解锁
• 通知对端,唤醒阻塞在条件变量上的对端

 GO标准库中的sys.Cond类型代表了条件变量。条件变量要与锁（互斥锁，或者读写锁）一起使用。成员变量L代表与条件变量搭配使用的锁。

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

对应的有3个常用方法，Wait，Signal，Broadcast。

func (c *Cond) Wait()

该函数的作用可归纳为如下三点：

• a) 阻塞等待条件变量满足
• b) 释放已掌握的互斥锁相当于cond.L.Unlock()。 注意：两步为一个原子操作。
• c) 当被唤醒，Wait()函数返回时，解除阻塞并重新获取互斥锁。相当于cond.L.Lock()

func (c *Cond) Signal()

• 单发通知，给一个正等待（阻塞）在该条件变量上的goroutine（线程）发送通知。

func (c *Cond) Broadcast()

• 广播通知，给正在等待（阻塞）在该条件变量上的所有goroutine（线程）发送通知。

下面我们用条件变量来编写一个“生产者消费者模型”

package main
import "fmt"
import "sync"
import "math/rand"
import "time"

var cond sync.Cond             // 创建全局条件变量

// 生产者
func producer(out chan<- int, idx int) {
   for {
      cond.L.Lock()               // 条件变量对应互斥锁加锁
      for len(out) == 3 {              // 产品区满 等待消费者消费
         cond.Wait()                 // 挂起当前协程， 等待条件变量满足，被消费者唤醒
      }
      num := rand.Intn(1000)     // 产生一个随机数
      out <- num                 // 写入到 channel 中 （生产）
      fmt.Printf("%dth 生产者，产生数据 %3d, 公共区剩余%d个数据\n", idx, num, len(out))
      cond.L.Unlock()                 // 生产结束，解锁互斥锁
      cond.Signal()               // 唤醒 阻塞的 消费者
      time.Sleep(time.Second)       // 生产完休息一会，给其他协程执行机会
   }
}
//消费者
func consumer(in <-chan int, idx int) {
   for {
      cond.L.Lock()               // 条件变量对应互斥锁加锁（与生产者是同一个）
      for len(in) == 0 {          // 产品区为空 等待生产者生产
         cond.Wait()                 // 挂起当前协程， 等待条件变量满足，被生产者唤醒
      }
      num := <-in                    // 将 channel 中的数据读走 （消费）
      fmt.Printf("---- %dth 消费者, 消费数据 %3d,公共区剩余%d个数据\n", idx, num, len(in))
      cond.L.Unlock()                 // 消费结束，解锁互斥锁
      cond.Signal()               // 唤醒 阻塞的 生产者
      time.Sleep(time.Millisecond * 500)        //消费完 休息一会，给其他协程执行机会
   }
}
func main() {
   rand.Seed(time.Now().UnixNano())  // 设置随机数种子
   quit := make(chan bool)           // 创建用于结束通信的 channel

   product := make(chan int, 3)      // 产品区（公共区）使用channel 模拟
   cond.L = new(sync.Mutex)          // 创建互斥锁和条件变量

   for i := 0; i < 5; i++ {          // 5个消费者
      go producer(product, i+1)
   }
   for i := 0; i < 3; i++ {          // 3个生产者
      go consumer(product, i+1)
   }
   <-quit                             // 主协程阻塞 不结束
}

1. main函数中定义quit，其作用是让主协程阻塞。
2. 定义product作为队列，生产者产生数据保存至队列中，最多存储3个数据，消费者从中取出数据模拟消费
3. 条件变量要与锁一起使用，这里定义全局条件变量cond，它有一个属性：L Locker。是一个互斥锁。
4. 开启5个消费者协程，开启3个生产者协程。
5. producer生产者，在该方法中开启互斥锁，保证数据完整性。并且判断队列是否满，如果已满，调用wait()让该goroutine阻塞。当消费者取出数后执行cond.Signal()，会唤醒该goroutine，继续生产数据。
6. consumer消费者，同样开启互斥锁，保证数据完整性。判断队列是否为空，如果为空，调用wait()使得当前goroutine阻塞。当生产者产生数据并添加到队列，执行cond.Signal() 唤醒该goroutine。

使用流程：

1. 创建 Cond 条件变量

2. 初始化条件变量 Cond.L := new(sync.Mutex)

3. 生产者：

1） 对条件变量内部锁，加锁。 Cond.L.lock()

2) 判断 是否应该阻塞 等待条件变量满足

for （len(ch）== 缓冲区容量） {
Cond.wait() 1. 阻塞 2. 解锁 --- 等待被唤醒--- 3.加锁
}

结论：判断 wait 是否调用的条件，在多生产者、消费者模型中，一定要使用 for

3） 向公共区写入数据

4） 解锁 Cond.L.Unlock()

5） 唤醒阻塞在条件变量上的 对端 ―― 消费者

Cond.signal() ---- broadcast
3. 消费者：

1） 对条件变量内部锁，加锁。 Cond.L.lock()

2) 判断 是否应该阻塞 等待条件变量满足

for（len(ch）== 0） {
Cond.wait() 1. 阻塞 2. 解锁 --- 等待被唤醒--- 3.加锁
}

结论：判断 wait 是否调用的条件，在多生产者、消费者模型中，一定要使用 for

3） 从公共区读出数据

4） 解锁 Cond.L.Unlock()

5） 唤醒阻塞在条件变量上的 对端 ―― 生产者

Cond.signal()