Go Concurrency: Mutexe vs. Kanäle mit Beispielen

Zählersynchronisation in der gleichzeitigen Go-Programmierung: Mutex, gepufferte Kanäle und ungepufferte Kanäle

Beim Erstellen gleichzeitiger Anwendungen in Go ist die Synchronisierung von entscheidender Bedeutung, um einen sicheren Zugriff auf gemeinsam genutzte Daten zu gewährleisten. Mutex und Channel sind die Hauptwerkzeuge für die Synchronisierung in Go.

In diesem Artikel werden verschiedene Möglichkeiten zum Erstellen sicherer Parallelitätszähler untersucht. Während der Referenzartikel dieses Problem mit Mutex löst, werden wir auch Alternativen mit gepufferten und ungepufferten Kanälen untersuchen.

Problembeschreibung

Wir müssen einen Zähler bauen, der gleichzeitig sicher verwendet werden kann.

Zählercode

<code class="language-go">package main

type Counter struct {
    count int
}

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

func (c *Counter) Value() int {
    return c.count
}</code>

Um unsere Code-Parallelität sicher zu machen, schreiben wir einige Tests.

1. Verwenden Sie Mutex

Mutex (Mutex) ist ein Synchronisationsprimitiv, das sicherstellt, dass jeweils nur eine Goroutine auf kritische Teile des Codes zugreifen kann. Es bietet einen Sperrmechanismus: Wenn eine Goroutine Mutex sperrt, werden andere Goroutinen, die versuchen, sie zu sperren, blockiert, bis Mutex entsperrt wird. Daher wird es häufig verwendet, wenn eine gemeinsam genutzte Variable oder Ressource vor Race Conditions geschützt werden muss.

<code class="language-go">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)
        }
    })
}</code>

Der Code verwendet sync.WaitGroup, um den Abschluss aller Goroutinen zu verfolgen, und verwendet sync.Mutex, um zu verhindern, dass mehrere Goroutinen gleichzeitig auf den gemeinsamen Zähler zugreifen.

2. Pufferkanal verwenden

Kanäle sind für Go eine Möglichkeit, Goroutinen eine sichere Kommunikation zu ermöglichen. Sie sind in der Lage, Daten zwischen Goroutinen zu übertragen und für Synchronisierung zu sorgen, indem sie den Zugriff auf die übergebenen Daten kontrollieren.

In diesem Beispiel verwenden wir Kanäle, um Goroutinen zu blockieren und nur einer Goroutine den Zugriff auf die gemeinsam genutzten Daten zu ermöglichen. Gepufferte Kanäle haben eine feste Kapazität, das heißt, sie können eine vordefinierte Anzahl von Elementen aufnehmen, bevor sie den Absender blockieren. Der Absender blockiert nur, wenn der Puffer voll ist.

<code class="language-go">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)
        }
    })
}</code>

Der Code verwendet einen gepufferten Kanal mit einer Kapazität von 1, sodass jeweils nur eine Goroutine auf den Zähler zugreifen kann.

3. Verwenden Sie nicht gepufferte Kanäle

Ungepufferte Kanäle haben keine Puffer. Sie blockieren den Sender, bis der Empfänger bereit ist, Daten zu empfangen. Dies sorgt für eine strikte Synchronisierung, bei der Daten einzeln zwischen Goroutinen übertragen werden.

<code class="language-go">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)
        }
    })
}
</code>

Der Code verwendet ungepufferte Kanäle, um sicherzustellen, dass jeweils nur eine Goroutine auf den Zähler zugreift.

4. Pufferkanal anstelle von WaitGroup verwenden

Wir können auch gepufferte Kanäle ohne WaitGroup verwenden, beispielsweise mithilfe einer Endlosschleife oder eines anderen Kanals, um den Abschluss der Goroutine zu verfolgen.

Fazit

In diesem Artikel werden verschiedene Ansätze zum Erstellen sicherer Parallelitätszähler in Go untersucht. Die Kenntnis dieser Tools und deren Verwendung ist der Schlüssel zum Schreiben effizienter und sicherer gleichzeitiger Go-Programme.

Referenzressourcen

Dieser Artikel ist vom Synchronisationskapitel in „Learn Go with Tests“ inspiriert.

Ich hoffe, dieser Artikel ist hilfreich für Sie!

Das obige ist der detaillierte Inhalt vonGo Concurrency: Mutexe vs. Kanäle mit Beispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!