Comment puis-je contrôler l'ordre d'exécution des Goroutines dans Go ?

Ordre d'exécution des goroutines Imprévisibilité

Dans l'extrait de code fourni, l'ordre d'exécution des deux goroutines est non déterministe. Le résultat montre que le deuxième goroutine s'exécute en premier, même s'il a été démarré après le premier. Ce comportement est dû à la nature concurrente des goroutines, ce qui signifie qu'elles s'exécutent indépendamment les unes des autres.

Mécanismes de synchronisation dans les goroutines

Pour contrôler l'ordre d'exécution des goroutines , vous pouvez utiliser les mécanismes de synchronisation fournis par Go, tels que :

Chaînes : Vous peut utiliser des canaux pour synchroniser l'exécution des goroutines. Un canal est un canal de communication qui permet aux goroutines d'envoyer et de recevoir des données. Dans l'exemple modifié ci-dessous, le canal est utilisé pour bloquer la goroutine principale jusqu'à ce que la première goroutine termine son exécution avant le démarrage de la deuxième goroutine.

func main() {

    c := make(chan int)

    go sum([]int{1, 2, 3}, c)

    // Use the channel to block until it receives a send
    x := <-c
    fmt.Println(x)

    // Then execute the next routine
    go sum([]int{4, 5, 6}, c)

    x = <-c
    fmt.Println(x)
}

Groupes d'attente : Un groupe d'attente est un autre mécanisme de synchronisation qui vous permet d'attendre que plusieurs goroutines terminent leur exécution avant de continuer. Dans l'exemple suivant, un groupe d'attente est utilisé pour garantir que toutes les goroutines sont terminées avant la sortie de la goroutine principale.

func sum(a []int, c chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Println("summing: ", a)
    total := 0
    for _, v := range a {
        total += v
    }
    // Send total to c
    c <- total
}

func main() {

    c := make(chan int)
    wg := new(sync.WaitGroup)

    // Concurrently call the concurrent calls to sum, allowing execution to continue to the range of the channel
    go func() {
        // Increment the wait group, and pass it to the sum func to decrement it when it is complete
        wg.Add(1)
        go sum([]int{1, 2, 3}, c, wg)
        // Wait for the above call to sum to complete
        wg.Wait()
        // And repeat...
        wg.Add(1)
        go sum([]int{4, 5, 6}, c, wg)
        wg.Wait()
        // All calls are complete, close the channel to allow the program to exit cleanly
        close(c)
    }()

    // Range of the channel
    for theSum := range c {
        x := theSum
        fmt.Println(x)
    }

}

En utilisant ces mécanismes de synchronisation, vous pouvez contrôler l'ordre d'exécution des goroutines et vous assurer que le la séquence d'opérations souhaitée est maintenue.

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!