文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Go语言sync.Cond如何使用

2023-07-05 14:11

关注

本篇内容介绍了“Go语言sync.Cond如何使用”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

基本使用

1 定义

sync.Cond是Go语言标准库中的一个类型,代表条件变量。条件变量是用于多个goroutine之间进行同步和互斥的一种机制。sync.Cond可以用于等待和通知goroutine,以便它们可以在特定条件下等待或继续执行。

2 方法说明

sync.Cond的定义如下,提供了Wait ,Singal,Broadcast以及NewCond方法

type Cond struct {   noCopy noCopy   // L is held while observing or changing the condition   L Locker   notify  notifyList   checker copyChecker}func NewCond(l Locker) *Cond {}func (c *Cond) Wait() {}func (c *Cond) Signal() {}func (c *Cond) Broadcast() {}

3 使用方式

当使用sync.Cond时,通常需要以下几个步骤:

4 使用例子    

下面是一个使用sync.Cond的简单示例,实现了一个生产者-消费者模型:

var (    // 1. 定义一个互斥锁    mu    sync.Mutex    cond  *sync.Cond    count int)func init() {    // 2.将互斥锁和sync.Cond进行关联    cond = sync.NewCond(&mu)}func worker(id int) {    // 消费者    for {        // 3. 在需要等待的地方,获取互斥锁,调用Wait方法等待被通知        mu.Lock()        // 这里会不断循环判断 是否有待消费的任务        for count == 0 {            cond.Wait() // 等待任务        }        count--        fmt.Printf("worker %d: 处理了一个任务\n", id)        // 5. 最后释放锁        mu.Unlock()    }}func main() {    // 启动5个消费者    for i := 1; i <= 5; i++ {        go worker(i)    }    for {        // 生产者        time.Sleep(1 * time.Second)        mu.Lock()        count++        // 4. 在需要等待的地方,获取互斥锁,调用BroadCast/Singal方法进行通知        cond.Broadcast()         mu.Unlock()    }}

在这个示例中,创建一个生产者在生产任务,同时创建五个消费者来消费任务。当任务数为0时,此时消费者会调用Wait方法进入阻塞状态,等待生产者的通知。

当生产者产生任务后,使用Broadcast方法通知所有的消费者,唤醒处于阻塞状态的消费者,开始消费任务。这里使用sync.Cond实现多个协程之间的通信和同步。

5 为什么Sync.Cond 需要关联一个锁,然后调用Wait方法前需要先获取该锁

这里的原因在于调用Wait方法前如果不加锁,有可能会出现竞态条件。

这里假设多个协程都处于等待状态,然后一个协程调用了Broadcast唤醒了其中一个或多个协程,此时这些协程都会被唤醒。

如下,假设调用Wait方法前没有加锁的话,那么所有协程都会去调用condition方法去判断是否满足条件,然后都通过验证,执行后续操作。

for !condition() {    c.Wait()}c.L.Lock()// 满足条件情况下,执行的逻辑c.L.Unlock()

此时会出现的情况为,本来是需要在满足condition方法的前提下,才能执行的操作。现在有可能的效果,为前面一部分协程执行时,还是满足condition条件的;但是后面的协程,尽管不满足condition条件,还是执行了后续操作,可能导致程序出错。

正确的用法应该是,在调用Wait方法前便加锁,那么即使多个协程被唤醒,一次也只会有一个协程判断是否满足condition条件,然后执行后续操作。这样子就不会出现多个协程同时判断,导致不满足条件,也执行后续操作的情况出现。

c.L.Lock()for !condition() {    c.Wait()}// 满足条件情况下,执行的逻辑c.L.Unlock()

使用场景

1 基本说明

sync.Cond是为了协调多个协程之间对共享数据的访问而设计的。使用sync.Cond的场景通常都涉及到对共享数据的操作,如果没有共享数据的操作,那么没有太大必要使用sync.Cond来进行协调。当然,如果存在重复唤醒的场景,即使没有对共享数据的操作,也是可以使用sync.Cond来进行协调的。

通常情况下,使用sync.Cond的场景为:多个协程需要访问同一份共享数据,需要等待某个条件满足后才能访问或修改这份共享数据。

在这些场景下,使用sync.Cond可以方便地实现对共享数据的协调,避免了多个协程之间的竞争和冲突,保证了共享数据的正确性和一致性。因此,如果没有涉及到共享数据的操作,就没有必要使用sync.Cond来进行协调。

2 场景说明

2.1 同步和协调多个协程之间共享资源

下面举一个使用 sync.Cond 的例子,用它来实现生产者-消费者模型。生产者往items放置元素,当items满了之后,便进入等待状态,等待消费者唤醒。消费者从items中取数据,当items空了之后,便进入等待状态,等待生产者唤醒。

这里多个协程对同一份数据进行操作,且需要基于该数据判断是否唤醒其他协程或进入阻塞状态,来实现多个协程的同步和协调。sync.Cond就适合在这种场景下使用,其正是为这种场景设计的。

package mainimport (        "fmt"        "sync"        "time")type Queue struct {        items []int        cap   int        lock  sync.Mutex        cond  *sync.Cond}func NewQueue(cap int) *Queue {        q := &amp;Queue{            items: make([]int, 0),            cap:   cap,        }        q.cond = sync.NewCond(&amp;q.lock)        return q}func (q *Queue) Put(item int) {        q.lock.Lock()        defer q.lock.Unlock()        for len(q.items) == q.cap {                q.cond.Wait()        }        q.items = append(q.items, item)        q.cond.Broadcast()}func (q *Queue) Get() int {        q.lock.Lock()        defer q.lock.Unlock()        for len(q.items) == 0 {            q.cond.Wait()        }        item := q.items[0]        q.items = q.items[1:]        q.cond.Broadcast()        return item}func main() {        q := NewQueue(10)        // Producer        go func() {            for {                q.Put(i)                fmt.Printf("Producer: Put %d\n", i)                time.Sleep(100 * time.Millisecond)            }        }()        // Consumer        go func() {            for {                    item := q.Get()                    fmt.Printf("Consumer: Get %d\n", item)                    time.Sleep(200 * time.Millisecond)            }        }()        wg.Wait()}
2.2 需要重复唤醒的场景中使用

在某些场景中,由于不满足某种条件,此时协程进入阻塞状态,等待条件满足后,由其他协程唤醒,再继续执行。在整个流程中,可能会多次进入阻塞状态,多次被唤醒的情况。

比如上面生产者和消费者模型的例子,生产者可能会产生一批任务,然后唤醒消费者,消费者消费完之后,会进入阻塞状态,等待下一批任务的到来。所以这个流程中,协程可能多次进入阻塞状态,然后再多次被唤醒。

sync.Cond能够实现即使协程多次进入阻塞状态,也能重复唤醒该协程。所以,当出现需要实现重复唤醒的场景时,使用sync.Cond也是非常合适的。

原理

1 基本原理

Sync.Cond存在一个通知队列,保存了所有处于等待状态的协程。通知队列定义如下:

type notifyList struct {   wait   uint32   notify uint32   lock   uintptr // key field of the mutex   head   unsafe.Pointer   tail   unsafe.Pointer}

当调用Wait方法时,此时Wait方法会释放所持有的锁,然后将自己放到notifyList等待队列中等待。此时会将当前协程加入到等待队列的尾部,然后进入阻塞状态。

当调用Signal 时,此时会唤醒等待队列中的第一个协程,其他继续等待。如果此时没有处于等待状态的协程,调用Signal不会有其他作用,直接返回。当调用BoradCast方法时,则会唤醒notfiyList中所有处于等待状态的协程。

sync.Cond的代码实现比较简单,协程的唤醒和阻塞已经由运行时包实现了,sync.Cond的实现直接调用了运行时包提供的API。

2 实现

 2.1 Wait方法实现

Wait方法首先调用runtime_notifyListAd方法,将自己加入到等待队列中,然后释放锁,等待其他协程的唤醒。

func (c *Cond) Wait() {   // 将自己放到等待队列中   t := runtime_notifyListAdd(&c.notify)   // 释放锁   c.L.Unlock()   // 等待唤醒   runtime_notifyListWait(&c.notify, t)   // 重新获取锁   c.L.Lock()}
2.2 Singal方法实现

Singal方法调用runtime_notifyListNotifyOne唤醒等待队列中的一个协程。

func (c *Cond) Signal() {   // 唤醒等待队列中的一个协程   runtime_notifyListNotifyOne(&c.notify)}
2.3 Broadcast方法实现

Broadcast方法调用runtime_notifyListNotifyAll唤醒所有处于等待状态的协程。

func (c *Cond) Broadcast() {   // 唤醒等待队列中所有的协程   runtime_notifyListNotifyAll(&c.notify)}

使用注意事项

1 调用Wait方法前未加锁

在上面2.5已经说明了,调用Sync.Cond方法前需要加锁,否则有可能出现竞态条件。而且,现有的sync.Cond的实现,如果在调用Wait方法前未加锁,此时会直接panic,下面是一个简单例子的说明:

package mainimport (    "fmt"    "sync"    "time")var (   count int   cond  *sync.Cond   lk    sync.Mutex)func main() {    cond = sync.NewCond(&lk)    wg := sync.WaitGroup{}    wg.Add(2)    go func() {       defer wg.Done()       for {          time.Sleep(time.Second)          count++          cond.Broadcast()       }    }()    go func() {       defer wg.Done()       for {          time.Sleep(time.Millisecond * 500)                    //cond.L.Lock()           for count%10 != 0 {               cond.Wait()          }          t.Logf("count = %d", count)          //cond.L.Unlock()         }    }()    wg.Wait()}

上面代码中,协程一每隔1s,将count字段的值自增1,然后唤醒所有处于等待状态的协程。协程二执行的条件为count的值为10的倍数,此时满足执行条件,唤醒后将会继续往下执行。

但是这里在调用sync.Wait方法前,没有先获取锁,下面是其执行结果,会抛出 fatal error: sync: unlock of unlocked mutex 错误,结果如下:

count = 0fatal error: sync: unlock of unlocked mutex

因此,在调用Wait方法前,需要先获取到与sync.Cond关联的锁,否则会直接抛出异常。

2 Wait方法接收到通知后,未重新检查条件变量

调用sync.Wait方法,协程进入阻塞状态后被唤醒,没有重新检查条件变量,此时有可能仍然处于不满足条件变量的场景下。然后直接执行后续操作,有可能会导致程序出错。下面举一个简单的例子:

package mainimport (    "fmt"    "sync"    "time")var (   count int   cond  *sync.Cond   lk    sync.Mutex)func main() {    cond = sync.NewCond(&lk)    wg := sync.WaitGroup{}    wg.Add(3)    go func() {       defer wg.Done()       for {          time.Sleep(time.Second)          cond.L.Lock()          // 将flag 设置为true          flag = true          // 唤醒所有处于等待状态的协程          cond.Broadcast()          cond.L.Unlock()       }    }()    for i := 0; i < 2; i++ {       go func(i int) {          defer wg.Done()          for {             time.Sleep(time.Millisecond * 500)             cond.L.Lock()             // 不满足条件,此时进入等待状态             if !flag {                cond.Wait()             }             // 被唤醒后,此时可能仍然不满足条件             fmt.Printf("协程 %d flag = %t", i, flag)             flag = false             cond.L.Unlock()          }       }(i)    }    wg.Wait()}

在这个例子,我们启动了一个协程,定时将flag设置为true,相当于每隔一段时间,便满足执行条件,然后唤醒所有处于等待状态的协程。

然后又启动了两个协程,在满足条件的前提下,开始执行后续操作,但是这里协程被唤醒后,没有重新检查条件变量,具体看第39行。这里会出现的场景是,第一个协程被唤醒后,此时执行后续操作,然后将flag重新设置为false,此时已经不满足条件了。之后第二个协程唤醒后,获取到锁,没有重新检查此时是否满足执行条件,直接向下执行,这个就和我们预期不符,可能会导致程序出错,代码执行效果如下:

协程 1 flag = true
协程 0 flag = false
协程 1 flag = true
协程 0 flag = false

可以看到,此时协程0执行时,flag的值均为false,说明此时其实并不符合执行条件,可能会导致程序出错。因此正确用法应该像下面这样子,被唤醒后,需要重新检查条件变量,满足条件之后才能继续向下执行。

c.L.Lock()// 唤醒后,重新检查条件变量是否满足条件for !condition() {    c.Wait()}// 满足条件情况下,执行的逻辑c.L.Unlock()

“Go语言sync.Cond如何使用”的内容就介绍到这里了,感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站,小编将为大家输出更多高质量的实用文章!

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯