Wie synchronisiere ich mehrere Threads in Go?

In Go kannst du mehrere Goroutinen (Threads) mithilfe von verschiedenen Synchronisationsmechanismen synchronisieren. Hier sind einige gängige Methoden:

1. **WaitGroup**: Mit `sync.WaitGroup` kannst du warten, bis eine Gruppe von Goroutinen abgeschlossen ist. Du fügst die Anzahl der Goroutinen hinzu, die du überwachen möchtest, und rufst `Done()` auf, wenn eine Goroutine fertig ist.

```go
var wg sync.WaitGroup

for i := 0; i < 5; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
// Deine Logik hier
}(i)
}

wg.Wait() // Warten, bis alle Goroutinen fertig sind
```

2. **Mutex**: Mit `sync.Mutex` kannst du kritische Abschnitte schützen, um sicherzustellen, dass nur eine Goroutine gleichzeitig auf einen bestimmten Codeabschnitt zugreift.

```go
var mu sync.Mutex
var sharedResource int

go func() {
mu.Lock()
sharedResource++
mu.Unlock()
}()
```

3. **Channel**: Channels sind ein weiteres wichtiges Synchronisationsmittel in Go. Sie ermöglichen die Kommunikation zwischen Goroutinen und können verwendet werden, um Daten sicher zu übertragen.

```go
ch := make(chan int)

go func() {
ch <- 42 // Senden von Daten an den Channel
}()

value := <-ch // Warten auf den Empfang von Daten
```

4. **Condition Variables**: Mit `sync.Cond` kannst du Goroutinen warten lassen, bis eine bestimmte Bedingung erfüllt ist.

```go
var mu sync.Mutex
cond := sync.NewCond(&mu)

go func() {
mu.Lock()
// Warten, bis eine Bedingung erfüllt ist
cond.Wait()
// Fortfahren, wenn die Bedingung erfüllt ist
mu.Unlock()
}()

// Irgendwann später
mu.Lock()
// Bedingung ändern
cond.Signal() // oder cond.Broadcast() für alle wartenden Goroutinen
mu.Unlock()
```

Diese Methoden helfen dir, die Synchronisation zwischen Goroutinen in Go effektiv zu steuern.