Wat wordt weergegeven bij het uitvoeren van het programma: func main() { counter := make([]int, 0, 1000) var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func() { defer wg.Done() counter = append(counter, i) time.Sleep(10 * time.Millisecond) // Werk simulatie }() } wg.Wait() fmt.Println(len(counter)) }

Het programma bevat een data race bij het schrijven naar de slice counter vanuit meerdere goroutines zonder synchronisatie. Dit leidt tot onvoorspelbaar gedrag.

Wat er gebeurt:

• Er wordt een slice counter gemaakt met lengte 0 en capaciteit 1000.
• Er worden 1000 goroutines gestart, elk probeert de waarde i toe te voegen aan de slice.
• De operatie append is niet thread-safe, meerdere goroutines wijzigen de slice gelijktijdig.
• Vanwege de data race kunnen gegevens verloren gaan, de slice beschadigd raken of een panic optreden.

Aan het einde:

• De waarde van len(counter) kan minder dan 1000 zijn, omdat sommige invoer verloren kunnen gaan.
• Er kan een panic of onjuiste output optreden.

De juiste aanpak is het gebruik van een mutex of kanaal om de toegang tot de slice te synchroniseren:

var mu sync.Mutex

for i := 0; i < 1000; i++ {
    wg.Add(1)
    go func(val int) {
        defer wg.Done()
        mu.Lock()
        counter = append(counter, val)
        mu.Unlock()
        time.Sleep(10 * time.Millisecond)
    }(i)
}

Of gebruik thread-safe datastructuren.