Go语言中sync.Cond使用详解

• sync.cond 可以用来干什么？
  
• 与 sync.mutex 的区别
  
• sync.cond 使用场景
  
• sync.cond
  

sync.cond 可以用来干什么？

golang 的 sync 包中的 cond 实现了一种条件变量，可以使用多个 reader 等待公共资源。

每个 cond 都会关联一个 lock ,当修改条件或者调用 wait 方法，必须加锁，保护 condition。 有点类似 java 中的 wait 和 notifyall。

sync.cond 条件变量是用来协调想要共享资源的那些 goroutine, 当共享资源的状态发生变化时，可以被用来通知被互斥锁阻塞的 gorountine。

与 sync.mutex 的区别

sync.cond 基于互斥锁，和互斥锁有什么区别？

sync.mutex 通常用来保护临界区和共享资源，条件变量 sync.cond 用来协调想要访问的共享资源。

sync.cond 使用场景

有一个协程正在接收数据，其他协程必须等待这个协程接收完数据，才能读取到正确的数据。

上述情形下，如果单纯的使用 channel 或者互斥锁，只能有一个协程可以等待，并读取到数据，没办法通知其他协程也读取数据。

这个时候怎么办？

• 可以用一个全局变量标识第一个协程是否接收数据完毕，剩下的协程反复检查该变量的值，直到读取到数据。
• 也可创建多个 channel, 每个协程阻塞在一个 channel 上，由接收数据的协程在数据接收完毕后，挨个通知。

然后 go 中其实内置来一个 sync.cond 来解决这个问题。

sync.cond

// each cond has an associated locker l (often a *mutex or *rwmutex),
// which must be held when changing the condition and
// when calling the wait method.
//
// a cond must not be copied after first use.
type cond struct {
        nocopy nocopy

        // l is held while observing or changing the condition
        l locker

        notify  notifylist
        checker copychecker
}

可以看到每个 cond 都会关联一个 锁 l (互斥锁 mutex, 或者读写锁 * rmmutex), 当修改条件或者使用 wait 的时候必须要加锁。

sync.cond 有哪些方法

newcond 创建实例

func newcond(l locker) *cond

newcond 创建实例需要关联一个锁。

具体实例：

cadence := sync.newcond(&sync.mutex{})

broadcast 广播唤醒所有

// broadcast wakes all goroutines waiting on c.
//
// it is allowed but not required for the caller to hold c.l
// during the call.
func (c *cond) broadcast()

broadcast 唤醒所有等待条件变量 c 的 goroutine，无需锁保护。

具体实例：

go func() {
   for range time.tick(1 * time.millisecond) {
      cadence.broadcast()
   }
}()

signal 唤醒一个协程

// signal wakes one goroutine waiting on c, if there is any.
//
// it is allowed but not required for the caller to hold c.l
// during the call.
func (c *cond) signal()

signal 只唤醒任意1个等待条件变量 c 的 goroutine，无需锁保护。 有点类似 java 中的 notify

wait 等待

// wait atomically unlocks c.l and suspends execution
// of the calling goroutine. after later resuming execution,
// wait locks c.l before returning. unlike in other systems,
// wait cannot return unless awoken by broadcast or signal.
//
// because c.l is not locked when wait first resumes, the caller
// typically cannot assume that the condition is true when
// wait returns. instead, the caller should wait in a loop:
//
//    c.l.lock()
//    for !condition() {
//        c.wait()
//    }
//    ... make use of condition ...
//    c.l.unlock()
//
func (c *cond) wait()

调用 wait 会自动释放锁 c.l，并挂起调用者所在的 goroutine，因此当前协程会阻塞在 wait 方法调用的地方。如果其他协程调用了 signal 或 broadcast 唤醒了该协程，wait 方法结束阻塞时，并重新给 c.l 加锁，并且继续执行 wait 后面的代码

代码示例：

c.l.lock()
for !condition() {
    c.wait()
}
... make use of condition ...
c.l.unlock()

代码示例

package sync

import (
   "log"
   "sync"
   "testing"
   "time"
)

var done = false

func read(name string, c *sync.cond) {
   c.l.lock()
   for !done {
      c.wait()
   }
   log.println(name, "starts reading")
   c.l.unlock()
}

func write(name string, c *sync.cond) {
   log.println(name, "starts writing")
   time.sleep(time.second)
   c.l.lock()
   done = true
   c.l.unlock()
   log.println(name, "wakes all")
   c.broadcast()
}

func testsynccond(t *testing.t) {
   cond := sync.newcond(&sync.mutex{})

   go read("reader1", cond)
   go read("reader2", cond)
   go read("reader3", cond)
   write("writer", cond)

   time.sleep(time.second * 3)
}

运行结果

=== run   testsynccond
2021/08/26 11:06:48 writer starts writing
2021/08/26 11:06:49 writer wakes all
2021/08/26 11:06:49 reader3 starts reading
2021/08/26 11:06:49 reader2 starts reading
2021/08/26 11:06:49 reader1 starts reading
--- pass: testsynccond (4.01s)
pass

到此这篇关于go语言中sync.cond使用详解的文章就介绍到这了,更多相关go sync.cond内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！