Golang中的sync.Cond怎么使用


本文小编为大家详细介绍“Golang中的sync.Cond怎么使用”,内容详细,步骤清晰,细节处理妥当,希望这篇“Golang中的sync.Cond怎么使用”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。 sync.Cond是Go语言标准库中的一个类型,代表条件变量。条件变量是用于多个goroutine之间进行同步和互斥的一种机制。sync.Cond可以用于等待和通知goroutine,以便它们可以在特定条件下等待或继续执行。sync.Cond的定义如下,提供了Wait ,Singal,Broadcast以及NewCond方法

typeCondstruct{
noCopynoCopy
//Lisheldwhileobservingorchangingthecondition
LLocker

notifynotifyList
checkercopyChecker
}

funcNewCond(lLocker)*Cond{}
func(c*Cond)Wait(){}
func(c*Cond)Signal(){}
func(c*Cond)Broadcast(){}

NewCond方法: 提供创建Cond实例的方法Wait方法: 使当前线程进入阻塞状态,等待其他协程唤醒Singal方法: 唤醒一个等待该条件变量的线程,如果没有线程在等待,则该方法会立即返回。Broadcast方法: 唤醒所有等待该条件变量的线程,如果没有线程在等待,则该方法会立即返回。当使用sync.Cond时,通常需要以下几个步骤:定义一个互斥锁,用于保护共享数据;创建一个sync.Cond对象,关联这个互斥锁;在需要等待条件变量的地方,获取这个互斥锁,并使用Wait方法等待条件变量被通知;在需要通知等待的协程时,使用SignalBroadcast方法通知等待的协程。最后,释放这个互斥锁。下面是一个使用sync.Cond的简单示例,实现了一个生产者-消费者模型:

var(
//1.定义一个互斥锁
musync.Mutex
cond*sync.Cond
countint
)

funcinit(){
//2.将互斥锁和sync.Cond进行关联
cond=sync.NewCond(&mu)
}

funcworker(idint){
//消费者
for{
//3.在需要等待的地方,获取互斥锁,调用Wait方法等待被通知
mu.Lock()
//这里会不断循环判断是否有待消费的任务
forcount==0{
cond.Wait()//等待任务
}
count--
fmt.Printf("worker%d:处理了一个任务n",id)
//5.最后释放锁
mu.Unlock()
}
}

funcmain(){
//启动5个消费者
fori:=1;i

在这个示例中,创建一个生产者在生产任务,同时创建五个消费者来消费任务。当任务数为0时,此时消费者会调用Wait方法进入阻塞状态,等待生产者的通知。当生产者产生任务后,使用Broadcast方法通知所有的消费者,唤醒处于阻塞状态的消费者,开始消费任务。这里使用sync.Cond实现多个协程之间的通信和同步。这里的原因在于调用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()

sync.Cond是为了协调多个协程之间对共享数据的访问而设计的。使用sync.Cond的场景通常都涉及到对共享数据的操作,如果没有共享数据的操作,那么没有太大必要使用sync.Cond来进行协调。当然,如果存在重复唤醒的场景,即使没有对共享数据的操作,也是可以使用sync.Cond来进行协调的。通常情况下,使用sync.Cond的场景为:多个协程需要访问同一份共享数据,需要等待某个条件满足后才能访问或修改这份共享数据。在这些场景下,使用sync.Cond可以方便地实现对共享数据的协调,避免了多个协程之间的竞争和冲突,保证了共享数据的正确性和一致性。因此,如果没有涉及到共享数据的操作,就没有必要使用sync.Cond来进行协调。下面举一个使用 sync.Cond 的例子,用它来实现生产者-消费者模型。生产者往items放置元素,当items满了之后,便进入等待状态,等待消费者唤醒。消费者从items中取数据,当items空了之后,便进入等待状态,等待生产者唤醒。这里多个协程对同一份数据进行操作,且需要基于该数据判断是否唤醒其他协程或进入阻塞状态,来实现多个免费云主机域名协程的同步和协调。sync.Cond就适合在这种场景下使用,其正是为这种场景设计的。

packagemain

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

typeQueuestruct{
items[]int
capint
locksync.Mutex
cond*sync.Cond
}

funcNewQueue(capint)*Queue{
q:=&Queue{
items:make([]int,0),
cap:cap,
}
q.cond=sync.NewCond(&q.lock)
returnq
}

func(q*Queue)Put(itemint){
q.lock.Lock()
deferq.lock.Unlock()

forlen(q.items)==q.cap{
q.cond.Wait()
}

q.items=append(q.items,item)
q.cond.Broadcast()
}

func(q*Queue)Get()int{
q.lock.Lock()
deferq.lock.Unlock()

forlen(q.items)==0{
q.cond.Wait()
}

item:=q.items[0]
q.items=q.items[1:]
q.cond.Broadcast()

returnitem
}

funcmain(){
q:=NewQueue(10)

//Producer
gofunc(){
for{
q.Put(i)
fmt.Printf("Producer:Put%dn",i)
time.Sleep(100*time.Millisecond)
}
}()

//Consumer
gofunc(){
for{
item:=q.Get()
fmt.Printf("Consumer:Get%dn",item)
time.Sleep(200*time.Millisecond)
}
}()

wg.Wait()
}

在某些场景中,由于不满足某种条件,此时协程进入阻塞状态,等待条件满足后,由其他协程唤醒,再继续执行。在整个流程中,可能会多次进入阻塞状态,多次被唤醒的情况。比如上面生产者和消费者模型的例子,生产者可能会产生一批任务,然后唤醒消费者,消费者消费完之后,会进入阻塞状态,等待下一批任务的到来。所以这个流程中,协程可能多次进入阻塞状态,然后再多次被唤醒。sync.Cond能够实现即使协程多次进入阻塞状态,也能重复唤醒该协程。所以,当出现需要实现重复唤醒的场景时,使用sync.Cond也是非常合适的。在Sync.Cond存在一个通知队列,保存了所有处于等待状态的协程。通知队列定义如下:

typenotifyListstruct{
waituint32
notifyuint32
lockuintptr//keyfieldofthemutex
headunsafe.Pointer
tailunsafe.Pointer
}

当调用Wait方法时,此时Wait方法会释放所持有的锁,然后将自己放到notifyList等待队列中等待。此时会将当前协程加入到等待队列的尾部,然后进入阻塞状态。当调用Signal 时,此时会唤醒等待队列中的第一个协程,其他继续等待。如果此时没有处于等待状态的协程,调用Signal不会有其他作用,直接返回。当调用BoradCast方法时,则会唤醒notfiyList中所有处于等待状态的协程。sync.Cond的代码实现比较简单,协程的唤醒和阻塞已经由运行时包实现了,sync.Cond的实现直接调用了运行时包提供的API。Wait方法首先调用runtime_notifyListAd方法,将自己加入到等待队列中,然后释放锁,等待其他协程的唤醒。

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

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

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

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

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

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

packagemain

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

var(
countint
cond*sync.Cond
lksync.Mutex
)

funcmain(){
cond=sync.NewCond(&lk)
wg:=sync.WaitGroup{}
wg.Add(2)
gofunc(){
deferwg.Done()
for{
time.Sleep(time.Second)
count++
cond.Broadcast()
}
}()

gofunc(){
deferwg.Done()
for{
time.Sleep(time.Millisecond*500)
//cond.L.Lock()
forcount%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=0
fatalerror:sync:unlockofunlockedmutex

因此,在调用Wait方法前,需要先获取到与sync.Cond关联的锁,否则会直接抛出异常。调用sync.Wait方法,协程进入阻塞状态后被唤醒,没有重新检查条件变量,此时有可能仍然处于不满足条件变量的场景下。然后直接执行后续操作,有可能会导致程序出错。下面举一个简单的例子:

packagemain

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

var(
countint
cond*sync.Cond
lksync.Mutex
)

funcmain(){
cond=sync.NewCond(&lk)
wg:=sync.WaitGroup{}
wg.Add(3)
gofunc(){
deferwg.Done()
for{
time.Sleep(time.Second)
cond.L.Lock()
//将flag设置为true
flag=true
//唤醒所有处于等待状态的协程
cond.Broadcast()
cond.L.Unlock()
}
}()

fori:=0;i

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

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

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

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

读到这里,这篇“Golang中的sync.Cond怎么使用”文章已经介绍完毕,想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会,如果想了解更多相关内容的文章,欢迎关注百云主机行业资讯频道。

相关推荐: jquery是不是基于js的

这篇“jquery是不是基于js的”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“jquery是不是基于js的”文章吧。 jquery是基于js的…

免责声明:本站发布的图片视频文字,以转载和分享为主,文章观点不代表本站立场,本站不承担相关法律责任;如果涉及侵权请联系邮箱:360163164@qq.com举报,并提供相关证据,经查实将立刻删除涉嫌侵权内容。

(0)
打赏 微信扫一扫 微信扫一扫
上一篇 05/26 09:06
下一篇 05/26 09:06

相关推荐