Pourquoi mon programme Go imprime-t-il parfois le résultat de la somme avant le « afficher le premier message » ?

Concurrence Go et confusion des canaux : comprendre l'ordre d'exécution de Goroutine

Dans Go, la concurrence est obtenue grâce à des goroutines, des threads légers qui s'exécutent simultanément au sein d'un processus unique. Les canaux fournissent un moyen de communication entre les goroutines. Cependant, comprendre comment les goroutines et les canaux interagissent peut être difficile, en particulier pour les débutants.

Cet article explore un point de confusion courant lié à l'ordre d'exécution des goroutines et à la communication des canaux. L'exemple de programme fourni :

<code class="go">package main

import "fmt"

func display(msg string, c chan bool) {
    fmt.Println("display first message:", msg)
    c <- true
}

func sum(c chan bool) {
    sum := 0
    for i := 0; i < 10000000000; i++ {
        sum++
    }
    fmt.Println(sum)
    c <- true
}

func main() {
    c := make(chan bool)

    go display("hello", c)
    go sum(c)
    <-c
}</code>

Ce programme devrait imprimer "afficher le premier message : bonjour" comme première sortie, suivi du résultat du calcul de la somme. Cependant, dans certains cas, le calcul de la somme se termine avant que la fonction d'affichage n'envoie les données au canal.

Explication :

Le planificateur de Go détermine l'ordre dans lequel les goroutines sont exécutés. Il n'est pas déterministe, ce qui signifie que l'ordre d'exécution peut varier en fonction de facteurs tels que le matériel et le système d'exploitation. Dans cet exemple :

1. La fonction principale crée deux goroutines : display et sum.
2. Le planificateur choisit de passer d'abord à la goroutine d'affichage, qui imprime la ligne "afficher le premier message" .
3. La goroutine d'affichage est bloquée lorsqu'elle tente d'envoyer des données au canal (c <- true) car il n'y a pas encore de récepteur.
4. Le planificateur choisit d'exécuter la somme goroutine, qui exécute la boucle coûteuse en calcul.
5. Une fois le calcul de la somme terminé, la goroutine de somme envoie des données au canal.
6. La fonction principale reçoit les données du canal et quitte.

Cependant, il est également possible pour le planificateur d'exécuter la goroutine de somme jusqu'à la fin avant que la goroutine d'affichage n'envoie des données au canal. Dans ce cas, le résultat serait :

10000000000
display first message: hello

Solution :

Pour garantir que le message affiché est imprimé avant le résultat de la somme, on peut utiliser un résultat canal pour recevoir le premier résultat et quitter le programme. La fonction principale modifiée serait :

<code class="go">func main() {
    result := make(chan string)

    go display("hello", result)
    go sum(result)
    fmt.Println(<-result)
}</code>

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!