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.