Pourquoi les Goroutines on Go Playground et les machines locales présentent-elles des différences comportementales ?

Différences entre Go Playground et la machine locale

Lors de l'exécution d'un code sur le Go Playground, les développeurs peuvent rencontrer des écarts par rapport à l'exécution du même code sur leurs machines locales. Cet article explore les différences de comportement, en particulier lorsqu'il s'agit de goroutines et de mécanismes de synchronisation.

Étude de cas : comportement du code sur Go Playground par rapport à la machine locale

Considérez le code Go suivant :

<code class="go">package main

import (
    "fmt"
)

func other(done chan bool) {
    done <- true
    go func() {
        for {
            fmt.Println("Here")
        }
    }()
}

func main() {
    fmt.Println("Hello, playground")
    done := make(chan bool)
    go other(done)
    <-done
    fmt.Println("Finished.")
}

Sur le Go Playground, ce code produit une erreur : "Le processus a pris trop de temps." Cela suggère que la goroutine créée dans l'autre fonction s'exécute indéfiniment.

Cependant, l'exécution du même code sur une machine locale avec plusieurs cœurs de processeur (GOMAXPROCS > 1) donne le résultat suivant :

<code class="text">Hello, playground
Finished.</code>

Cela implique que la goroutine créée dans un autre se termine lorsque la goroutine principale se termine.

Expliquer l'écart comportemental

Le comportement différent entre le terrain de jeu Go et la machine locale peut être attribué au nombre de processeurs disponibles. Sur le terrain de jeu Go, GOMAXPROCS a la valeur par défaut 1, ce qui signifie qu'une seule goroutine peut s'exécuter à la fois. Par conséquent, dans l'exemple ci-dessus, la goroutine sans fin créée dans d'autres empêche la goroutine principale de continuer.

En revanche, lors d'une exécution locale avec plusieurs cœurs de processeur, GOMAXPROCS utilise par défaut le nombre de cœurs disponibles, permettant à plusieurs goroutines de fonctionner. s'exécutent simultanément. Ainsi, la goroutine sans fin créée dans les autres n'empêche pas la goroutine principale de sortir.

Conclusion

Le comportement des goroutines dans Go dépend du nombre de processeurs disponibles (GOMAXPROCS). Alors que le terrain de jeu Go utilise une valeur par défaut de 1, ce qui peut donner l'impression que les goroutines s'exécutent indéfiniment, l'exécution du même code sur une machine locale avec plusieurs cœurs fournit un comportement différent dans lequel les goroutines peuvent se terminer lorsque la goroutine principale se termine. Cette compréhension aide les développeurs à éviter les malentendus et garantit que leur code se comporte comme prévu dans différents environnements.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!