Go語言sync.Cond基本使用及原理範例詳解

2023-03-21 06:01:11

1. 簡介

本文將介紹 Go 語言中的 sync.Cond 並行原語，包括 sync.Cond的基本使用方法、實現原理、使用注意事項以及常見的使用使用場景。能夠更好地理解和應用 Cond 來實現 goroutine 之間的同步。

2. 基本使用

2.1 定義

sync.Cond是Go語言標準庫中的一個型別，代表條件變數。條件變數是用於多個goroutine之間進行同步和互斥的一種機制。sync.Cond可以用於等待和通知goroutine，以便它們可以在特定條件下等待或繼續執行。

2.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() {}

NewCond方法：提供建立Cond範例的方法
Wait方法: 使當前執行緒進入阻塞狀態，等待其他協程喚醒
Singal方法: 喚醒一個等待該條件變數的執行緒，如果沒有執行緒在等待，則該方法會立即返回。
Broadcast方法: 喚醒所有等待該條件變數的執行緒，如果沒有執行緒在等待，則該方法會立即返回。

2.3 使用方式

當使用sync.Cond時，通常需要以下幾個步驟：

定義一個互斥鎖，用於保護共用資料；
建立一個sync.Cond物件，關聯這個互斥鎖；
在需要等待條件變數的地方，獲取這個互斥鎖，並使用Wait方法等待條件變數被通知；
在需要通知等待的協程時，使用Signal或Broadcast方法通知等待的協程。
最後，釋放這個互斥鎖。

2.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實現多個協程之間的通訊和同步。

2.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()

3.使用場景

3.1 基本說明

sync.Cond是為了協調多個協程之間對共用資料的存取而設計的。使用sync.Cond的場景通常都涉及到對共用資料的操作，如果沒有共用資料的操作，那麼沒有太大必要使用sync.Cond來進行協調。當然，如果存在重複喚醒的場景，即使沒有對共用資料的操作，也是可以使用sync.Cond來進行協調的。

通常情況下，使用sync.Cond的場景為：多個協程需要存取同一份共用資料，需要等待某個條件滿足後才能存取或修改這份共用資料。

在這些場景下，使用sync.Cond可以方便地實現對共用資料的協調，避免了多個協程之間的競爭和衝突，保證了共用資料的正確性和一致性。因此，如果沒有涉及到共用資料的操作，就沒有必要使用sync.Cond來進行協調。

3.2 場景說明

3.2.1 同步和協調多個協程之間共用資源

下面舉一個使用 sync.Cond 的例子，用它來實現生產者-消費者模型。生產者往items放置元素，當items滿了之後，便進入等待狀態，等待消費者喚醒。消費者從items中取資料，當items空了之後，便進入等待狀態，等待生產者喚醒。

這裡多個協程對同一份資料進行操作，且需要基於該資料判斷是否喚醒其他協程或進入阻塞狀態，來實現多個協程的同步和協調。sync.Cond就適合在這種場景下使用，其正是為這種場景設計的。

package main
import (
        "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 %dn", i)
                time.Sleep(100 * time.Millisecond)
            }
        }()
        // Consumer
        go func() {
            for {
                    item := q.Get()
                    fmt.Printf("Consumer: Get %dn", item)
                    time.Sleep(200 * time.Millisecond)
            }
        }()
        wg.Wait()
}

3.2.2 需要重複喚醒的場景中使用

在某些場景中，由於不滿足某種條件，此時協程進入阻塞狀態，等待條件滿足後，由其他協程喚醒，再繼續執行。在整個流程中，可能會多次進入阻塞狀態，多次被喚醒的情況。

比如上面生產者和消費者模型的例子，生產者可能會產生一批任務，然後喚醒消費者，消費者消費完之後，會進入阻塞狀態，等待下一批任務的到來。所以這個流程中，協程可能多次進入阻塞狀態，然後再多次被喚醒。

sync.Cond能夠實現即使協程多次進入阻塞狀態，也能重複喚醒該協程。所以，當出現需要實現重複喚醒的場景時，使用sync.Cond也是非常合適的。

4. 原理

4.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。

4.2 實現

4.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()
}

4.2.2 Singal方法實現

Singal方法呼叫runtime_notifyListNotifyOne喚醒等待佇列中的一個協程。

func (c *Cond) Signal() {
   // 喚醒等待佇列中的一個協程
   runtime_notifyListNotifyOne(&c.notify)
}

4.2.3 Broadcast方法實現

Broadcast方法呼叫runtime_notifyListNotifyAll喚醒所有處於等待狀態的協程。

func (c *Cond) Broadcast() {
   // 喚醒等待佇列中所有的協程
   runtime_notifyListNotifyAll(&c.notify)
}

5.使用注意事項

5.1 呼叫Wait方法前未加鎖

在上面2.5已經說明了，呼叫Sync.Cond方法前需要加鎖，否則有可能出現競態條件。而且，現有的sync.Cond的實現，如果在呼叫Wait方法前未加鎖，此時會直接panic，下面是一個簡單例子的說明:

package main
import (
    "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 = 0
fatal error: sync: unlock of unlocked mutex

因此，在呼叫Wait方法前，需要先獲取到與sync.Cond關聯的鎖，否則會直接丟擲異常。

5.2 Wait方法接收到通知後，未重新檢查條件變數

呼叫sync.Wait方法，協程進入阻塞狀態後被喚醒，沒有重新檢查條件變數，此時有可能仍然處於不滿足條件變數的場景下。然後直接執行後續操作，有可能會導致程式出錯。下面舉一個簡單的例子:

package main
import (
    "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()

6.總結

本文介紹了 Go 語言中的 sync.Cond 並行原語，它是用於實現 goroutine 之間的同步的重要工具。我們首先學習了 sync.Cond 的基本使用方法，包括建立和使用條件變數、使用Wait和Signal/Broadcast方法等。

接著，我們對 sync.Cond 的使用場景進行了說明，如同步和協調多個協程之間共用資源等。

在接下來的部分中，我們介紹了 sync.Cond 的實現原理，主要是對等待佇列的使用，從而sync.Cond有更好的理解，能夠更好得使用它。同時，我們也講述了使用sync.Cond的注意事項，如呼叫Wait方法前需要加鎖等。

基於以上內容，本文完成了對 sync.Cond 的介紹，希望能夠幫助大家更好地理解和使用Go語言中的並行原語。

更多關於Go語言sync.Cond原理的資料請關注it145.com其它相關文章！