Est-ce un résultat de l'optimisation du compilateur ?

Dans cet extrait de code, une goroutine est lancée et incrémente à plusieurs reprises la variable i :

package main

import "time"

func main() {
    i := 1
    go func() {
        for {
            i  
        }
    }()
    
Cependant, la sortie est toujours 1. Ce comportement peut être attribué au modèle de mémoire Go et à l'implémentation spécifique de ce code.
Le modèle de mémoire Go
Le modèle de mémoire Go
Le Le modèle de mémoire Go définit les conditions dans lesquelles les lectures d'une variable dans une goroutine peuvent être garanties pour observer les valeurs produites par les écritures dans la même variable dans une goroutine différente. Il souligne l'importance de la synchronisation pour l'accès simultané aux données partagées.
Omettre la synchronisation
Dans le code donné :
L'affectation à i (c'est-à-dire i ) n'est suivi d'aucun événement de synchronisation, indiquant que les modifications peuvent ne pas être immédiatement visibles par les autres goroutines.
Le compilateur peut optimiser cette optimisation de boucle en la simplifiant à un non-op.
Optimisation par le compilateur
for {}
pour {}
Exemple avec synchronisation
 
package main

import (
    "sync"
    "time"
)

func main() {
    mx := new(sync.Mutex)
    i := 1
    go func() {
        for {
            mx.Lock()
            i  
            mx.Unlock()
        }
    }()
    
package main

importer (
    "synchroniser"
    "temps"
)

fonction main() {
    mx := nouveau(sync.Mutex)
    je := 1
    allez func() {
        pour {
            mx.Lock()
            je  
            mx.Déverrouiller()
        }
    }()
    
Dans ce cas, la sortie n'est plus 1, mais un grand nombre, comme prévu. Le sync.Mutex assure la synchronisation et garantit que les deux goroutines accèdent à i de manière contrôlée, permettant à la goroutine d'incrémenter i et rendant les modifications visibles à la routine principale.