Go 並發：互斥體與通道的範例

Go 並發程式設計中的計數器同步：Mutex、緩衝通道和非緩衝通道

在 Go 語言中建立並發應用程式時，同步至關重要，以確保安全地存取共享資料。 Mutex 和 Channel 是 Go 中用於同步的主要工具。

本文探討了建構安全並發計數器的幾種方法。雖然參考文章使用 Mutex 解決了這個問題，但我們也將探討使用緩衝通道和非緩衝通道的替代方法。

問題描述

我們需要建立一個可以安全地並發使用的計數器。

計數器代碼

package main

type Counter struct {
    count int
}

func (c *Counter) Inc() {
    c.count++
}

func (c *Counter) Value() int {
    return c.count
}

為了確保程式碼的並發安全，讓我們來寫一些測試。

1. 使用 Mutex

Mutex（互斥鎖）是一種同步原語，它確保一次只有一個 goroutine 可以存取程式碼的關鍵部分。它提供了一種鎖機制：當一個 goroutine 鎖定 Mutex 時，其他試圖鎖定它的 goroutine 將被阻塞，直到 Mutex 被解鎖。因此，當需要保護共享變數或資源免受競爭條件影響時，通常會使用它。

package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using mutexes and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        var mut sync.Mutex

        wg.Add(wantedCount)

        for i := 0; i < wantedCount; i++ {
            go func() {
                defer wg.Done()
                mut.Lock()
                counter.Inc()
                mut.Unlock()
            }()
        }

        wg.Wait()
        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}

程式碼使用了 sync.WaitGroup 來追蹤所有 goroutine 的完成情況，並使用 sync.Mutex 來防止多個 goroutine 同時存取共享計數器。

2. 使用緩衝通道

通道是 Go 允許 goroutine 安全通訊的一種方式。它們能夠在 goroutine 之間傳輸數據，並透過控制對所傳遞數據的存取來提供同步。

在本例中，我們將利用通道來阻塞 goroutine，並只允許一個 goroutine 存取共享資料。緩衝通道具有固定的容量，這意味著它們可以在阻塞發送方之前容納預先定義數量的元素。只有當緩衝區已滿時，發送方才會被阻塞。

package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using buffered channels and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        wg.Add(wantedCount)

        ch := make(chan struct{}, 1)

        ch <- struct{}{} // 允许第一个 goroutine 开始

        for i := 0; i < wantedCount; i++ {
            go func() {
                defer wg.Done()
                <-ch
                counter.Inc()
                ch <- struct{}{}
            }()
        }

        wg.Wait()
        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}

程式碼使用容量為 1 的緩衝通道，允許一次只有一個 goroutine 存取計數器。

3. 使用非緩衝通道

非緩衝通道沒有緩衝區。它們會阻塞發送方，直到接收方準備好接收資料。這提供了嚴格的同步，其中資料一次一個地傳遞到 goroutine 之間。

package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using unbuffered channels and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        wg.Add(wantedCount)

        ch := make(chan struct{})

        go func() {
            for i := 0; i < wantedCount; i++ {
                ch <- struct{}{}
            }
            close(ch)
        }()

        for range ch {
            counter.Inc()
            wg.Done()
        }

        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}

程式碼使用非緩衝通道，確保一次只有一個 goroutine 存取計數器。

4. 使用緩衝通道，不使用 WaitGroup

我們也可以使用緩衝通道而不使用 WaitGroup，例如使用無限循環或另一個通道來追蹤 goroutine 的完成情況。

結論

本文探討了在 Go 中建構安全並發計數器的不同方法。掌握這些工具以及何時使用它們是編寫高效且安全的並發 Go 程式的關鍵。

參考資源

本文受《Learn Go with tests》中同步章節的啟發。

希望這篇文章對您有幫助！

以上是Go 並發：互斥體與通道的範例的詳細內容。更多資訊請關注PHP中文網其他相關文章！