• [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。

  • 相关阅读:
    linux下自动同步internet时间
    String,StringBuffer与StringBuilder的区别
    Spring Boot CLI安装
    java中Date与String的相互转化
    MyBatis Sql语句中的转义字符
    MyBatis详解 与配置MyBatis+Spring+MySql
    MyBatis的foreach语句详解
    不可变集合 Immutable Collections
    Java日期时间使用总结
    Java将一段逗号分割的字符串转换成一个数组
  • 原文地址:https://www.cnblogs.com/liujunhang/p/12539915.html
Copyright © 2020-2023  润新知