Maison > Article > développement back-end > Programmation hautement concurrente et compétition de ressources en langage Go
Avec le développement rapide d'Internet et de l'Internet mobile, de plus en plus d'applications doivent gérer des requêtes à forte concurrence. Comment gérer efficacement ces requêtes est devenu un défi pour les développeurs. Le langage Go est devenu le langage de choix dans les scénarios à forte concurrence en raison de son mécanisme de traitement simultané efficace et de ses fonctionnalités linguistiques faciles à utiliser. Cet article présentera les connaissances liées à la programmation à haute concurrence et à la concurrence entre les ressources dans le langage Go.
1. La programmation simultanée en langage Go
La programmation simultanée en langage Go est implémentée via goroutine. Goroutine est un thread léger qui peut s'exécuter sur une petite pile. Il est démarré et détruit rapidement. Il peut exécuter des milliers de goroutines en même temps pour atteindre une concurrence élevée. Ce qui suit est un exemple simple de goroutine :
func main() { go func() { // goroutine逻辑 }() }
Une autre caractéristique très importante de la programmation simultanée en langage Go est le canal, qui est un pont de communication entre les goroutines. Channel est une file d'attente thread-safe qui prend en charge la synchronisation et l'exclusion mutuelle entre différentes goroutines. Une implémentation de canal simple est la suivante :
func main() { ch := make(chan int) go func() { // goroutine逻辑 ch <- 1 }() <-ch }
Dans le code ci-dessus, un canal ch est d'abord créé, puis une goroutine est démarrée, une certaine logique y est exécutée et le résultat est envoyé au canal via ch. Enfin, la fonction principale attend que la goroutine termine son exécution via l'opération de réception (<-ch) avant de se terminer.
2. Compétition des ressources
Dans un environnement multithread, la compétition des ressources est un problème courant. Dans le langage Go, l'accès aux variables partagées peut provoquer des conflits de ressources car plusieurs goroutines peuvent accéder à la même variable partagée en même temps, conduisant à des résultats imprévisibles.
Ce qui suit est un code de démonstration simple :
func main() { var count int for i := 0; i < 10000; i++ { go func() { count++ }() } fmt.Println("count:", count) }
Dans le code ci-dessus, 10 000 goroutines sont démarrées et chaque goroutine en ajoutera une au nombre de variables partagées. Cependant, comme l’ordre d’exécution des goroutines est incertain, le résultat final l’est également. Dans le test local, le résultat du décompte est parfois 9 996, parfois 9 998 et parfois 10 000.
Afin d'éviter cette situation, nous devons utiliser le mécanisme de verrouillage fourni dans le langage Go pour verrouiller et déverrouiller les variables partagées afin de garantir qu'une seule goroutine puisse gérer les variables partagées en même temps. Ce qui suit est un exemple de code amélioré :
func main() { var count int mu := sync.Mutex{} for i := 0; i < 10000; i++ { go func() { mu.Lock() count++ mu.Unlock() }() } time.Sleep(time.Second) // 等待goroutine执行完毕 fmt.Println("count:", count) }
Dans le code ci-dessus, nous utilisons le type Mutex fourni par le package de synchronisation pour verrouiller (mu.Lock()) et déverrouiller ( mu.Unlock()) opération pour garantir qu’un seul goroutine peut opérer sur des variables partagées en même temps. Afin de garantir que toutes les goroutines sont exécutées, nous attendons ici 1 seconde via la fonction Sleep fournie par le package time.
3. Précautions pour la programmation à haute concurrence
Dans la programmation à haute concurrence, vous devez faire attention aux points suivants :
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!