Go語言中sync.Cond使用詳解

Posted on by

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內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：