Wie verwende ich Synchronisierungsprimitive, um die Parallelität von Goroutinen zu verhindern?

Um Parallelitätsprobleme zu vermeiden, können Sie Synchronisierungsprimitive verwenden, darunter: Mutex: Ermöglicht jeweils nur einer Goroutine den Zugriff auf gemeinsam genutzte Daten. Semaphor: Begrenzen Sie die Anzahl der Goroutinen, die gleichzeitig auf gemeinsam genutzte Daten zugreifen können. WaitGroup: Warten Sie, bis eine Gruppe von Goroutinen die Ausführung abgeschlossen hat. Bedingungsvariable: Ermöglicht Goroutine, auf die Erfüllung bestimmter Bedingungen zu warten. Praktischer Fall: Verwenden Sie Mutex, um Parallelität und Datenwettbewerbsprobleme zu verhindern, indem Sie den Zugriff von Goroutine auf gemeinsam genutzte Ressourcen koordinieren.

So verwenden Sie Synchronisierungsprimitive, um Goroutine-Parallelität zu verhindern

In der Go-Sprache sind Goroutinen gleichzeitige Funktionen, die sich denselben Speicherplatz teilen. Dies kann zu Parallelitätsproblemen wie Datenwettläufen führen, die auftreten, wenn mehrere Goroutinen gleichzeitig auf gemeinsam genutzte Variablen zugreifen.

Um Parallelitätsprobleme zu vermeiden, können Sie Synchronisierungsprimitive verwenden. Dabei handelt es sich um Techniken, mit denen der Zugriff auf gemeinsam genutzte Variablen koordiniert wird.

Gemeinsame Synchronisierungsprimitive

Die Go-Sprache bietet mehrere Synchronisierungsprimitive, darunter:

• Mutex (Mutex) : Es ermöglicht jeweils nur einer Goroutine, auf gemeinsam genutzte Daten zuzugreifen.
• Semaphore: Es begrenzt die Anzahl der Goroutinen, die gleichzeitig auf gemeinsam genutzte Daten zugreifen können.
• WaitGroup (Wartegruppe): Wird verwendet, um darauf zu warten, dass eine Gruppe von Goroutinen die Ausführung abschließt.
• Bedingungsvariable: Sie ermöglicht der Goroutine, auf die Erfüllung einer bestimmten Bedingung zu warten.

Praktischer Fall: Verwenden Sie Mutex, um Parallelität zu verhindern

Lassen Sie uns anhand eines praktischen Falls veranschaulichen, wie Mutex verwendet wird, um Parallelität zu verhindern. Stellen Sie sich ein Szenario vor, in dem wir eine Counter-Struktur haben, die ein count-Feld enthält. Wir möchten diesen Zähler gleichzeitig mithilfe gleichzeitiger Goroutinen aktualisieren. Counter 结构，其中包含一个 count 字段。我们希望使用并发 Goroutine 并发更新该计数器。

package main

import (
    "fmt"
    "sync"
)

// Counter represents a simple counter.
type Counter struct {
    mu     sync.Mutex
    count  int
}

// Increment increments the count by 1.
func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}

// GetCount returns the current value of the count.
func (c *Counter) GetCount() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}

func main() {
    // Create a new counter.
    c := &Counter{}

    // Create a group of Goroutines to increment the counter concurrently.
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            c.Increment()
        }()
    }

    // Wait for all Goroutines to finish.
    wg.Wait()

    // Print the final count.
    fmt.Println("Final count:", c.GetCount())
}

在这个案例中，Mutex 用于保护对 count 字段的访问。当一个 Goroutine 尝试更新计数器时，它会先获取 Mutexrrreee

Das obige ist der detaillierte Inhalt vonWie verwende ich Synchronisierungsprimitive, um die Parallelität von Goroutinen zu verhindern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!