Méthode de contrôle de l'ordre d'exécution des Goroutines et des canaux dans Golang

Méthode de contrôle de séquence d'exécution des Goroutines et des canaux dans Golang

Dans la programmation Golang, Goroutine et Channel sont deux concepts très importants. Goroutine est un thread léger qui peut exécuter plusieurs fonctions simultanément lors de l'exécution du programme. Le canal est un mécanisme utilisé pour la communication entre les Goroutines.

Dans certains cas, nous devons contrôler l'ordre d'exécution de Goroutine et Channel pour garantir que le programme s'exécute comme prévu. Cet article présentera quelques méthodes courantes pour implémenter le contrôle de séquence de Goroutine et Channel.

Méthode 1 : Utiliser WaitGroup

WaitGroup est un compteur utilisé pour attendre la fin d'un groupe de Goroutines. Son principe de fonctionnement est qu'à chaque fois qu'un Goroutine est démarré, le compteur est incrémenté de un ; après l'exécution de chaque Goroutine, le compteur est décrémenté de un. Lorsque le compteur atteint zéro, le thread principal poursuit son exécution.

Ce qui suit est un exemple de code utilisant WaitGroup pour le contrôle de séquence :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    wg.Add(2)

    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 1")
    }()

    go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2")
    }()

    wg.Wait()

    fmt.Println("Main Goroutine")
}

Dans cet exemple, nous créons deux Goroutines, chaque Goroutine imprime un message. Dans chaque Goroutine, on passe defer wg.Done() 语句将计数器减一。最后，wg.Wait() pour bloquer le thread principal jusqu'à ce que toutes les Goroutines soient exécutées.

Exécutez le code ci-dessus, le résultat est :

Goroutine 1
Goroutine 2
Main Goroutine

On peut voir que l'ordre d'exécution de Goroutine 1 et Goroutine 2 est incertain, mais ils doivent être terminés avant que le thread principal n'imprime "Main Goroutine".

Méthode 2 : Utiliser un canal sans tampon

Un canal sans tampon peut être utilisé pour bloquer l'exécution d'un Goroutine jusqu'à ce qu'un autre Goroutine reçoive des données du canal. En construisant une chaîne de dépendances Goroutine, nous pouvons exécuter plusieurs Goroutines de manière séquentielle.

Ce qui suit est un exemple de code pour un contrôle séquentiel utilisant un canal sans tampon :

package main

import (
    "fmt"
)

func main() {
    ch1 := make(chan struct{})
    ch2 := make(chan struct{})

    go func() {
        fmt.Println("Goroutine 1")
        ch1 <- struct{}{}
    }()

    go func() {
        <-ch1
        fmt.Println("Goroutine 2")
        ch2 <- struct{}{}
    }()

    <-ch2

    fmt.Println("Main Goroutine")
}

Dans cet exemple, après que Goroutine 1 ait imprimé un message, il envoie une structure vide au canal ch1. Ensuite, Goroutine 2 imprime un autre message après avoir reçu les données du canal ch1 et envoie une structure vide au canal ch2. Enfin, le thread principal imprime "Main Goroutine" après avoir reçu les données du canal ch2.

Exécutez le code ci-dessus, le résultat est :

Goroutine 1
Goroutine 2
Main Goroutine

Vous pouvez voir que l'ordre d'exécution de Goroutine 1 et Goroutine 2 est déterminé, et ils doivent être terminés avant que le thread principal n'imprime "Main Goroutine".

Méthode 3 : Utiliser un canal tamponné

Un canal tamponné nous permet de spécifier une capacité lors de sa création, qui peut stocker une certaine quantité de données. En définissant la taille du tampon de manière appropriée, nous pouvons contrôler le nombre d'exécutions simultanées de Goroutine et réaliser un contrôle de séquence.

Ce qui suit est un exemple de code pour un contrôle séquentiel utilisant un canal tamponné :

package main

import (
    "fmt"
)

func main() {
    ch := make(chan struct{}, 2)

    go func() {
        fmt.Println("Goroutine 1")
        ch <- struct{}{}
    }()

    go func() {
        fmt.Println("Goroutine 2")
        ch <- struct{}{}
    }()

    <-ch
    <-ch

    fmt.Println("Main Goroutine")
}

Dans cet exemple, nous créons un canal ch avec un tampon de capacité 2. Dans chaque Goroutine, nous envoyons une structure vide au canal ch. Enfin, le thread principal imprime "Main Goroutine" après avoir reçu deux fois les données de ch Channel.

Exécutez le code ci-dessus, le résultat est :

Goroutine 1
Goroutine 2
Main Goroutine

Vous pouvez voir que l'ordre d'exécution de Goroutine 1 et Goroutine 2 est déterminé, et ils doivent être terminés avant que le thread principal n'imprime "Main Goroutine".

Grâce à la méthode ci-dessus, nous pouvons contrôler de manière flexible l'ordre d'exécution de Goroutine et Channel. En fonction des besoins réels, le choix de la méthode appropriée peut améliorer la simultanéité et l'efficacité du programme.

Résumé :

Cet article présente trois méthodes courantes pour contrôler l'ordre d'exécution de Goroutine et Channel dans Golang : utiliser WaitGroup, utiliser Channel sans tampon et utiliser Channel avec tampon. En utilisant rationnellement ces méthodes, un contrôle flexible de la concurrence peut être obtenu et les performances et l'efficacité du programme peuvent être améliorées.

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!