Go語言中sync.Cond的使用詳解

這篇文章主要介紹“Go語言中sync.Cond的使用詳解”，在日常操作中，相信很多人在Go語言中sync.Cond的使用詳解問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Go語言中sync.Cond的使用詳解”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

目錄

• sync.Cond 可以用來干什么？
  

• 與 Sync.Mutex 的區別
  

• sync.Cond 使用場景
  

• sync.Cond
  

• sync.Cond 有哪些方法
  

• NewCond 創建實例
  

• Broadcast 廣播喚醒所有
  

• Signal 喚醒一個協程
  

• Wait 等待
  

• 代碼示例
  

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的使用詳解”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！