Que sera affiché lors de l'exécution du programme: 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) // Simulation de travail }() } wg.Wait() fmt.Println(len(counter)) }

Le programme contient une course de données lors de l’écriture dans la tranche counter depuis plusieurs goroutines sans synchronisation. Cela conduit à un comportement imprévisible.

Ce qui se passe :

• Une tranche counter est créée avec une longueur de 0 et une capacité de 1000.
• 1000 goroutines sont lancées, chacune essayant d’ajouter la valeur i à la tranche.
• L’opération append n’est pas sûre pour les threads, plusieurs goroutines modifient la tranche simultanément.
• En raison de la course de données, il peut y avoir une perte de données, une corruption de la tranche ou une panique.

En sortie :

• La valeur de len(counter) peut être inférieure à 1000, car certaines entrées peuvent être perdues.
• Une panique ou une sortie incorrecte peut se produire.

L’approche correcte consiste à utiliser un mutex ou un canal pour synchroniser l’accès à la tranche :

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

Ou utiliser des structures de données thread-safe.