Comment faire de la concurrence dans Golang

Golang est un langage efficace, rapide et hautement sécurisé, et ses fonctionnalités de concurrence en font un outil de plus en plus populaire et puissant. Cet article commence par les concepts de base et présente comment Golang implémente la concurrence.

1. Concurrence et parallélisme

La première chose qui doit être clarifiée est la différence entre la concurrence et le parallélisme. La concurrence fait référence à plusieurs tâches qui se chevauchent et s'exécutent au cours de la même période, tandis que le parallélisme fait référence à plusieurs tâches s'exécutant en même temps. En pratique, on confond souvent les deux, mais en théorie, ce sont des concepts complètement différents.

2. La goroutine de Golang

La concurrence de Golang dépend principalement de la goroutine. Goroutine est un fil de discussion léger en Golang, démarré par le mot-clé go. La plus grande différence entre la goroutine et les threads est qu'elle ne repose pas sur les threads du système d'exploitation pour son exécution, mais est directement gérée par le système d'exécution de Golang. Chaque goroutine est une unité indépendante planifiée par l'environnement d'exécution du langage Go (runtime). Ils s'exécuteront dans un processeur logique. Le processeur logique détermine l'allocation de la goroutine au nombre réel de threads dans le système d'exploitation.

Dans les programmes Golang, la fonction principale s'exécute par défaut dans une goroutine, et d'autres goroutines peuvent être démarrées à tout moment et peuvent être exécutées simultanément avec la fonction principale ou d'autres goroutines.

3. Utilisez le mot-clé go pour démarrer goroutine

Utilisez le mot-clé go pour démarrer facilement goroutine. Il suffit d'ajouter le mot-clé go avant l'appel de la fonction, et le système ouvrira automatiquement une nouvelle goroutine si nécessaire. Par exemple :

go func1(arg1, arg2)

Cette instruction exécutera la fonction func1 sous forme de goroutine et le code de synchronisation continuera à s'exécuter. À ce stade, le programme imprimera d’abord cette instruction, puis exécutera immédiatement le code suivant. À un certain moment, le runtime du langage Go démarrera une nouvelle goroutine pour exécuter la fonction. Dans ce cas, on ne peut pas savoir directement quand la goroutine est démarrée et quand elle se termine.

Pour les fonctions avec des valeurs de retour, nous devons attendre que la goroutine termine son exécution avant de passer à l'étape suivante. Ce processus peut être réalisé en utilisant des canaux.

4. Channel

Channel est un mécanisme de communication très important dans la programmation simultanée Golang. Les canaux permettent l'échange de données entre les goroutines. Les canaux ont toujours des opérations d'envoi et de réception, qui se bloquent par défaut jusqu'à ce que l'autre extrémité soit prête.

La syntaxe pour créer un canal est la suivante :

channel := make(chan type)

où le type peut être n'importe quel type, et le canal est un tube avec type type.

La syntaxe pour envoyer des données au canal est la suivante :

channel <- data

Cette instruction enverra des données au canal et les enverra à la goroutine en attente de recevoir les données.

La syntaxe pour recevoir les données du canal dans goroutine est la suivante :

data := <- channel

Cette instruction recevra les données du canal. S'il n'y a pas de données dans le canal, cette instruction bloquera l'attente de l'arrivée des données.

Grâce aux canaux, nous pouvons contrôler la synchronisation et la concurrence entre les goroutines. Par exemple :

ch := make(chan int)
go func(){
    ch <- 1
}()
data := <- ch

Cette instruction attendra que la goroutine envoie des données au canal après avoir démarré une nouvelle goroutine, puis recevra des données du canal pour continuer l'exécution.

5. Forfait Sync

En plus des chaînes, Golang propose également un package Sync pour prendre en charge la programmation simultanée. Ce package fournit de nombreuses fonctions et mécanismes d'opération atomique tels que les verrous mutex.

La fonction d'opération atomique est un concept très important dans la programmation simultanée Golang. Elle peut garantir qu'une série d'opérations est indivisible lorsqu'elle est exécutée, c'est-à-dire que les autres goroutines ne peuvent pas voir l'état intermédiaire lors de l'exécution d'opérations atomiques, et l'objet est soit. ne pas être modifié, ni être modifié. Cela peut très bien résoudre le problème de synchronisation.

Par exemple :

var sum int64 = 0
for i := 0; i < 10000; i++ {
    go func(){
        atomic.AddInt64(&sum, 1)
    }()
}

Cette instruction démontre l'utilisation de fonctions d'opération atomique pour effectuer des calculs. Dans ce programme, la goroutine ajoutera continuellement 1 à la variable somme sans créer de conditions de concurrence. Ce problème causé par le manque de synchronisation des variables de lecture et d'écriture est appelé condition de concurrence critique, et les fonctions d'opération atomique peuvent parfaitement éviter ce problème.

6. Résumé

Cet article présente comment Golang implémente la concurrence. Il parle principalement d'éléments de base tels que la goroutine de Golang, les canaux et les opérations atomiques dans le package Sync, ainsi que de leur application en programmation simultanée. Les fonctionnalités de concurrence de Golang sont non seulement utiles dans de nombreux domaines tels que le traitement des tâches d'ingénierie, le traitement simultané des serveurs et le développement de systèmes en temps réel, mais sont également l'une des raisons importantes pour lesquelles Golang est devenu un langage de programmation populaire.

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!