Golang Concurrent Programming : compréhension approfondie des principes et de l'utilisation des Goroutines

Programmation simultanée Golang : compréhension approfondie des principes et de l'utilisation des Goroutines

[Introduction]
Avec l'augmentation du nombre de cœurs de processeur informatique, la programmation multithread est devenue un moyen important pour améliorer les performances et la réactivité des applications. Cependant, le modèle de programmation multithread traditionnel présente une certaine complexité et difficulté de mise en œuvre et de débogage. Dans Golang, les Goroutines offrent un moyen simple et puissant de programmation simultanée. Cet article explorera en profondeur les principes et l'utilisation des Goroutines.

[Principe des Goroutines]
Les Goroutines sont des threads légers de Golang, qui sont planifiés par le système d'exécution du langage Go (Goruntime). Par rapport aux threads ordinaires, la surcharge de création et de destruction des Goroutines est très faible, de sorte qu'un grand nombre de Goroutines peuvent être créés pour exécuter des tâches simultanément.

L'implémentation de Goroutines est basée sur le modèle de thread M:N, qui mappe M Goroutines à N threads du système d'exploitation. De cette manière, plusieurs Goroutines peuvent être exécutées en même temps, que ce soit sur un ordinateur monocœur ou multicœur, pour utiliser pleinement les performances des ressources informatiques.

【Création et planification de Goroutines】
Dans Golang, vous pouvez créer une Goroutine en utilisant le mot-clé go. Voici un exemple de code simple :

func main() {
    go printHello()
    fmt.Println("Main Goroutine")
    time.Sleep(time.Second)
}

func printHello() {
    time.Sleep(time.Second)
    fmt.Println("Hello Goroutine")
}

Dans le code ci-dessus, la fonction printHello est créée en tant que Goroutine, qui sera exécutée de manière asynchrone. Dans la fonction principale, nous pouvons voir que le programme affichera d'abord "Main Goroutine", puis attendra une seconde, puis affichera "Hello Goroutine".

Goruntime est responsable de la planification des Goroutines, qui alloue les Goroutines à exécuter aux threads disponibles du système d'exploitation. Sur un thread du système d'exploitation, Goruntime maintient une file d'attente Goroutine et sélectionne le prochain Goroutine à exécuter en fonction de la politique de planification. Si un Goroutine est bloqué (par exemple en attente d'une opération d'E/S), Goroutine le suspendra temporairement et changera d'exécution dans d'autres Goroutines.

【Communication entre Goroutines】
En programmation simultanée, les Goroutines ont besoin de communiquer et de partager des données. Golang fournit Channel pour y parvenir. Les canaux sont un type spécial dans Golang qui permettent aux Goroutines d'envoyer et de recevoir des données en toute sécurité entre eux.

Ce qui suit est un exemple de code pour la communication utilisant des canaux :

func main() {
    ch := make(chan string)
    go sendMessage(ch, "Hello Goroutine!")
    msg := <-ch
    fmt.Println(msg)
}

func sendMessage(ch chan<- string, msg string) {
    time.Sleep(time.Second)
    ch <- msg
}

Dans le code ci-dessus, nous créons un canal ch de type chaîne et utilisons le mot-clé go pour démarrer la fonction sendMessage en tant que Goroutine. La fonction sendMessage enverra le message au canal. Dans la fonction principale, nous utilisons la syntaxe <-ch pour recevoir les messages du canal et les imprimer.

[Synchronisation et exclusion mutuelle des Goroutines]
Lorsque plusieurs Goroutines accèdent à des ressources partagées en même temps, des problèmes de condition de concurrence peuvent survenir. Afin de garantir l'exactitude et la cohérence des ressources, Golang fournit des verrous mutex (Mutex) et des verrous en lecture-écriture (RWMutex) pour réaliser la synchronisation des ressources et l'exclusion mutuelle.

Voici un exemple de code pour la synchronisation à l'aide d'un mutex :

func main() {
    var counter int
    var wg sync.WaitGroup
    var mu sync.Mutex

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go increment(&counter, &wg, &mu)
    }

    wg.Wait()
    fmt.Println("Counter:", counter)
}

func increment(counter *int, wg *sync.WaitGroup, mu *sync.Mutex) {
    mu.Lock()
    *counter++
    mu.Unlock()

    wg.Done()
}

Dans le code ci-dessus, nous créons une variable de compteur partagée et la protégeons à l'aide d'un mutex mu. Dans la fonction d'incrémentation, nous utilisons mu.Lock() et mu.Unlock() pour verrouiller et libérer le mutex respectivement.

【Résumé】
Grâce à cet article, nous avons découvert les principes et l'utilisation des Goroutines dans la programmation simultanée Golang. Les Goroutines fournissent une méthode de programmation simultanée simple et puissante qui permet d'utiliser pleinement les ressources informatiques. Nous avons découvert la création et la planification des Goroutines, la communication entre les Goroutines et comment utiliser les verrous mutex pour la synchronisation. J'espère que cet article vous aidera à mieux comprendre la programmation simultanée Golang.

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!