La concurrence Golang est-elle dangereuse ?

Golang, en tant que langage de programmation relativement jeune, a attiré de plus en plus d'attention et d'amour grâce à son développement rapide ces dernières années. Le mécanisme de concurrence intégré de Golang le rend favorisé par de nombreux développeurs, mais l'utilisation du mécanisme de concurrence entraînera des dangers cachés, en particulier lorsque la concurrence n'est pas sûre, cela peut entraîner une série de problèmes dans le programme. Cet article explorera les raisons et les solutions de la concurrence non sécurisée dans Golang.

1. Raisons pour lesquelles la concurrence n'est pas sûre

1. Condition de concurrence

Une condition de concurrence signifie que lorsque plusieurs threads accèdent à des ressources partagées, en raison d'opérations différentes, les résultats sont confus. Dans Golang, les conditions de concurrence sont plus évidentes en raison de l'exécution asynchrone des coroutines.

2. Concurrence de données

La concurrence de données signifie que plusieurs coroutines accèdent à la même zone mémoire en même temps et qu'au moins une coroutine effectue une opération d'écriture. En raison du mécanisme de concurrence de Golang, différentes coroutines ont des temps d'exécution différents, de sorte que plusieurs coroutines peuvent modifier la même zone mémoire en même temps.

3. Deadlock

Deadlock fait référence à une situation dans laquelle deux ou plusieurs coroutines s'attendent pour libérer des ressources et ne peuvent pas continuer l'exécution. Cette situation peut se produire lors de l'utilisation d'un verrou. Si le verrou est mal utilisé, un blocage se produira.

2. Exemple de concurrence non sécurisée dans Golang

Ce qui suit est un exemple simple pour expliquer le problème de concurrence non sécurisée dans Golang :

package main 
import (
   "fmt"
   "sync"
)
var num = 0 
func add(wg *sync.WaitGroup) {
   num++ 
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg)
   }
   wg.Wait()
   fmt.Println("num=", num)
}

Dans cet exemple, nous définissons une variable globale num et utilisons une coroutine pour appeler la méthode add, incrémenter le nombre de 1000 fois. En raison de l'exécution asynchrone des coroutines, l'ordre d'exécution de ce programme est incertain. Si ce code exécute plusieurs coroutines en même temps, une concurrence de données se produira et le résultat de num pourrait ne pas être le 1 000 attendu.

3. Comment éviter la concurrence dangereuse dans Golang

1. Utiliser des verrous

Les verrous sont l'une des méthodes couramment utilisées pour résoudre les problèmes de concurrence dangereux. Golang fournit une variété d'implémentations de verrouillage, telles que sync.Mutex, sync.RWMutex. , etc. . L'utilisation de verrous peut garantir qu'une seule coroutine peut accéder à une certaine ressource en même temps, évitant ainsi l'apparition d'une concurrence entre les données.

Modifiez l'exemple ci-dessus et utilisez sync.Mutex pour éviter les courses de données :

package main 
import (
   "fmt"
   "sync"
)
var num = 0 
func add(wg *sync.WaitGroup, lock *sync.Mutex) {
   lock.Lock() 
   num++ 
   lock.Unlock()
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   var lock sync.Mutex 
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg, &lock)
   }
   wg.Wait()
   fmt.Println("num=", num)
}

Dans cet exemple, nous utilisons sync.Mutex pour garantir que les modifications apportées à num sont atomiques. Cela évite l’apparition de courses aux données.

2. Utiliser des opérations atomiques

Golang fournit une série d'opérations atomiques pour garantir que le fonctionnement d'une certaine ressource est atomique. Utilisez des opérations atomiques pour éviter les conditions de concurrence critique, telles que AddInt32, AddInt64, SwapInt32, SwapInt64, etc. dans le package sync/atomic.

Modifiez l'exemple ci-dessus et utilisez des opérations atomiques pour éviter les courses de données :

package main 
import (
   "fmt"
   "sync/atomic"
   "sync"
)
var num int32 
func add(wg *sync.WaitGroup) {
   atomic.AddInt32(&num,1) 
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg)
   }
   wg.Wait()
   fmt.Println("num=", num)
}

Dans cet exemple, nous utilisons la fonction AddInt32 dans le package sync/atomic pour garantir que la modification de num est atomique et évite les conditions de concurrence.

3. Utiliser les canaux

Les canaux sont un mécanisme de synchronisation très couramment utilisé dans la programmation simultanée Golang. Les canaux peuvent garantir que la communication entre les coroutines est synchrone, évitant ainsi les conditions de concurrence et les problèmes de compétition de données.

Modifiez l'exemple ci-dessus et utilisez des canaux pour éviter les courses aux données :

package main 
import (
   "fmt"
   "sync"
)
func add(wg *sync.WaitGroup, ch chan int) {
   ch <- 1 
   wg.Done()
}
func main() {
   var wg sync.WaitGroup
   ch := make(chan int, 1000)
   for i := 0; i < 1000; i++ {
      wg.Add(1)
      go add(&wg, ch)
   }
   wg.Wait()
   close(ch)
   num := 0 
   for n := range ch {
      num += n
   }
   fmt.Println("num=", num)
}

Dans cet exemple, nous utilisons des canaux pour garantir que les modifications apportées à num sont synchronisées, évitant ainsi l'apparition de courses aux données.

4. Résumé

Le mécanisme de concurrence de Golang est l'une de ses fonctionnalités très attrayantes, mais l'utilisation du mécanisme de concurrence pose également certains problèmes de sécurité. Cet article traite des raisons et des solutions à la concurrence dangereuse de Golang et propose des solutions principalement pour éviter la concurrence des données, les conditions de concurrence et les blocages dans la concurrence. Dans le processus de programmation proprement dit, nous pouvons choisir le mécanisme approprié en fonction des besoins spécifiques afin de garantir la qualité et la sécurité du programme.

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!