[golang]锁和条件变量

锁和条件变量

在go中，解决协程同步的问题可以使用channel，但是除了channel，在go中还提供了传统的同步工具。

这些内容都被包含在标准库代码包sync和sync/atomic中。

在传统的工具中，使用较多的是互斥锁和读写锁。

那么什么是锁呢？

就是某个协程（线程）在访问某个资源时先锁住，防止其它协程的访问，等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似，例如：公共卫生间。

如果对进程和线程没有理解，可以读 这篇文章。

在正式的说互斥锁和读写锁之前，先来说说常见的一种情况，死锁。

死锁

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，

例如，下面的代码中就是一种常见的死锁状态，当使用 channel时，只有一种操作状态。

package main

func main() {
	ch := make(chan int)

	<- ch
}

运行编译，直接出现下面的错误：

fatal error: all goroutines are asleep - deadlock!

一般来说，死锁可以分成几种：

• 单go程自己死锁。

  • channel应该在至少两个以上go程中进行通信，否则死锁！！！

• go程间channel访问顺序导致死锁。

  • ​ 使用channel一端读(或者写)，要保证另一端写(或者读)，同时有机会执行。

• 多go程，多channel交叉死锁。

  • // 创建两个channel
    ch1 := make(chan int)
    ch2 := make(chan int)
    
    // 创建一个子go程
    go func() {
      for {
        select {
          // 读取ch1 channel当中的值
          case num := <- ch1:
          ch2 <- num // 将读到的值写给channel2
        }
      }
    }()
    
    for {
      select {
        // 读取ch2 channel的值
        case num := <- ch2 :
        ch1 <- num  // 将读到的值写给ch1 channel
      }
    }
    

互斥锁(互斥量)

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

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

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

var mutex sync.Mutex		// 定义互斥锁变量 mutex

func write(){
   mutex.Lock( )
   defer mutex.Unlock( )
}

我们可以使用互斥锁来解决前面提到的多任务编程的问题，如下所示：

package main

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

/*
当我们进行同步资源访问的时候，可以通过互斥锁保证只能有一个协程（线程）访问该资源。
其它的协程只能等待。

互斥锁(互斥量):
	互斥锁是建议锁。
	A、B go程共同访问共享数据。由于cpu调度所及，需要对共享数据访问顺序加以限定(同步)
	创建mutex(互斥锁)，访问共享数据之前加锁，访问结束，解锁。在A go程加锁期间，B go程加锁失败 -- 阻塞
	直至A go程解锁mutex，B从阻塞处恢复执行。
*/

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

func printer(s string) {
	// 当进行资源访问的时候，先上锁
	mutex.Lock()
	// 资源访问结束在解锁
	defer mutex.Unlock()
	for _,val := range s {
		fmt.Printf("%c",val)
		time.Sleep(time.Second)
	}
}

func worker1() {
	printer("hello")
}

func worker2() {
	printer("world")
}

func main() {
	fmt.Println(mutex)
	go worker1()
	go worker2()

	for {
		;
	}
}

运行结果如下：

{0 0}
helloworld
Process finished with exit code 130 (interrupted by signal 2: SIGINT)

程序执行结果与多任务资源竞争时一致。最终由于添加了互斥锁，可以按序先输出hello再输出 world。但这里需要我们自行创建互斥锁，并在适当的位置对锁进行释放。

读写锁

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

其实，当我们对一个不会变化的数据只做“读”操作的话，是不存在资源竞争的问题的。因为数据是不变的，不管怎么读取，多少goroutine同时读取，都是可以的。

所以问题不是出在“读”上，主要是修改，也就是“写”。修改的数据要同步，这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。

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

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

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

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

func (*RWMutex)Lock()

func (*RWMutex)Unlock()

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

func (*RWMutex)RLock()

func (*RWMutex)RUlock()

读写锁基本示例：

package main

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

var count int           		// 全局变量count
var rwlock sync.RWMutex       	// 全局读写锁 rwlock

func read(n int)  {
   rwlock.RLock()
   fmt.Printf("读 goroutine %d 正在读取数据...
", n)
   num := count
   fmt.Printf("读 goroutine %d 读取数据结束，读到 %d
", n, num)
   defer rwlock.RUnlock()
}
func write(n int)  {
   rwlock.Lock()
   fmt.Printf("写 goroutine %d 正在写数据...
", n)
   num := rand.Intn(1000)
   count = num
   fmt.Printf("写 goroutine %d 写数据结束，写入新值 %d
", n, num)
   defer rwlock.Unlock()
}

func main()  {
   for i:=0; i<5; i++ {
      go read(i+1)
   }
   for i:=0; i<5; i++ {
      go write(i+1)
   }
   for {
      ;
   }
}

程序运行结果如下：

在go语言中，尽量不要将互斥锁、读写锁 与 channel 混用 。-- 隐性死锁

我们在read里使用读锁，也就是RLock和RUnlock，写锁的方法名和我们平时使用的一样，是Lock和Unlock。这样，我们就使用了读写锁，可以并发地读，但是同时只能有一个写，并且写的时候不能进行读操作。

我们从结果可以看出，读取操作可以并行，例如2,3,1正在读取，但是同时只能有一个写，例如1正在写，只能等待1写完，这个过程中不允许进行其它的操作。

处于读锁定状态，那么针对它的写锁定操作将永远不会成功，且相应的Goroutine也会被一直阻塞。因为它们是互斥的。

总结：读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间不存在互斥关系。

从互斥锁和读写锁的源码可以看出，它们是同源的。读写锁的内部用互斥锁来实现写锁定操作之间的互斥。可以把读写锁看作是互斥锁的一种扩展。

条件变量

条件变量本身不是锁，但是经常和锁一起使用。

在讲解条件变量之前，先回顾一下前面我们所涉及的“生产者消费者模型”：

package main

import "fmt"

//只写，不读。
func producer(out chan<- int)  {
   for i:= 0; i < 10; i++ {
      out <- i*i          		
   }
   close(out)
}
//只读，不写
func consumer(in <-chan int)  {
   for num := range in {		
      fmt.Println("num = ", num)
   }
}
func main()  {
   ch := make(chan int)		// 创建一个双向channel
   go producer(ch)     		// 生产者，产生数据，写入 channel
   consumer(ch)      		// 消费者，从channel读数据，打印到屏幕
}

这个案例中，虽然实现了生产者消费者的功能，但有一个问题。如果有多个消费者来消费数据，并且并不是简单的从channel中取出来进行打印，而是还要进行一些复杂的运算。在consumer( )方法中的实现是否有问题呢？如下所示：

package main

import "fmt"
import "sync"
import "time"

var sum int 

func producer(out chan<- int) {
for i := 0; i < =100; i++ {
	out <-i
}
close(out);
}

// 此chanel 只能读，不能写
func consumer(in <-chan int) {
for num := range in {
	sum +=num
}
fmt.println(“sum = ”, sum) 
}

func main() {
    
    ch:= make(chan int)	// 创建一个双向通道
    go producer(ch)		// 协程1，生产者，生产数字，写入channel
    go consumer(ch)		// 协程2，消费者1
    consumer(ch)		// 主协程，消费者。从channel读取内容打印
    for  {
       ;
    }
}

在上面的代码中，加了一个消费者，同时在consumer方法中，将数据取出来后，又进行了一组运算。这时可能会出现一个协程从管道中取出数据，参与加法运算，但是还没有算完另外一个协程又从管道中取出一个数据赋值给了num变量。所以这样累加计算，很有可能出现问题。当然，按照前面的知识，解决这个问题的方法很简单，就是通过加锁的方式来解决。增加生产者也是一样的道理。

另外一个问题，如果消费者比生产者多，仓库中就会出现没有数据的情况。我们需要不断的通过循环来判断仓库队列中是否有数据，这样会造成cpu的浪费。反之，如果生产者比较多，仓库很容易满，满了就不能继续添加数据，也需要循环判断仓库满这一事件，同样也会造成CPU的浪费。

我们希望当仓库满时，生产者停止生产，等待消费者消费；同理，如果仓库空了，我们希望消费者停下来等待生产者生产。为了达到这个目的，这里引入条件变量。（需要注意：如果仓库队列用channel，是不存在以上情况的，因为channel被填满后就阻塞了，或者channel中没有数据也会阻塞）。

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

例如，我们上面说的，如果仓库队列满了，我们可以使用条件变量让生产者对应的goroutine暂停（阻塞），但是当消费者消费了某个产品后，仓库就不再满了，应该唤醒（发送通知给）阻塞的生产者goroutine继续生产产品。

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。

1) func (c *Cond) Wait()

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

a) 阻塞等待条件变量满足

b) 释放已掌握的互斥锁相当于cond.L.Unlock()。 注意：两步为一个原子操作。

c) 当被唤醒，Wait()函数返回时，解除阻塞并重新获取互斥锁。相当于cond.L.Lock()

2) *func (c *Cond) Signal()

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

3) 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个数据
", 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个数据
", 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。