Was wird beim Ausführen des Programms ausgegeben: 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) // Arbeitssimulation }() } wg.Wait() fmt.Println(len(counter)) }

Das Programm enthält einen Datenrennen beim Schreiben in den Slice counter aus mehreren Goroutinen ohne Synchronisation. Dies führt zu unvorhersehbarem Verhalten.

Was passiert:

• Es wird ein Slice counter mit Länge 0 und Kapazität 1000 erstellt.
• Es werden 1000 Goroutinen gestartet, die versuchen, den Wert i in das Slice einzufügen.
• Die Operation append ist nicht thread-sicher, mehrere Goroutinen modifizieren das Slice gleichzeitig.
• Aufgrund des Datenrennens können Daten verloren gehen, das Slice beschädigt werden oder es kommt zu einem Panic.

Am Ende:

• Der Wert von len(counter) kann kleiner als 1000 sein, da einige Einträge verloren gehen können.
• Es kann zu einem Panic oder falscher Ausgabe kommen.

Der richtige Ansatz ist die Verwendung eines Mutex oder Kanals, um den Zugriff auf das Slice zu synchronisieren:

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)
}

Oder die Verwendung thread-sicherer Datenstrukturen.