Go 并發(fā)編程中的計數(shù)器同步：Mutex、緩沖通道和非緩沖通道

在 Go 語言中構(gòu)建并發(fā)應用程序時，同步至關重要，以確保安全地訪問共享數(shù)據(jù)。Mutex 和 Channel 是 Go 中用于同步的主要工具。

本文探討了構(gòu)建安全并發(fā)計數(shù)器的幾種方法。雖然參考文章使用 Mutex 解決了這個問題，但我們還將探討使用緩沖通道和非緩沖通道的替代方法。

問題描述

我們需要構(gòu)建一個可以安全地并發(fā)使用的計數(shù)器。

計數(shù)器代碼

package main

type Counter struct {
    count int
}

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

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

為了確保代碼的并發(fā)安全，讓我們編寫一些測試。

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 同時訪問共享計數(shù)器。

2. 使用緩沖通道

通道是 Go 允許 goroutine 安全通信的一種方式。它們能夠在 goroutine 之間傳輸數(shù)據(jù)，并通過控制對所傳遞數(shù)據(jù)的訪問來提供同步。

在本例中，我們將利用通道來阻塞 goroutine，并只允許一個 goroutine 訪問共享數(shù)據(jù)。緩沖通道具有固定的容量，這意味著它們可以在阻塞發(fā)送方之前容納預定義數(shù)量的元素。只有當緩沖區(qū)已滿時，發(fā)送方才會被阻塞。

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 訪問計數(shù)器。

3. 使用非緩沖通道

非緩沖通道沒有緩沖區(qū)。它們會阻塞發(fā)送方，直到接收方準備好接收數(shù)據(jù)。這提供了嚴格的同步，其中數(shù)據(jù)一次一個地傳遞到 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 訪問計數(shù)器。

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

我們還可以使用緩沖通道而不使用 WaitGroup，例如使用無限循環(huán)或另一個通道來跟蹤 goroutine 的完成情況。

結(jié)論

本文探討了在 Go 中構(gòu)建安全并發(fā)計數(shù)器的不同方法。掌握這些工具以及何時使用它們是編寫高效且安全的并發(fā) Go 程序的關鍵。

參考資源

本文受《Learn Go with tests》中同步章節(jié)的啟發(fā)。

希望本文對您有所幫助！

以上是Go 并發(fā)：互斥體與通道的示例的詳細內(nèi)容。更多信息請關注PHP中文網(wǎng)其他相關文章！