Le golang mutex

Un mutex fait référence à un mécanisme de verrouillage qui garantit qu'une seule fonction ou Goroutine accéde à une section spécifique d'un programme à la fois. C'est un élément essentiel de la gestion de la concurrence qui empêche les conditions de course.

Une condition de course fait référence à une instance où plus d'un thread tente d'accéder aux données partagées.

Dans cet article, nous discuterons des bases de la mise en œuvre d'un mutex à l'aide du package Go Sync.

Package de synchronisation Golang

Le package de synchronisation dans GO nous fournit des outils et des méthodes pour implémenter des tâches de synchronisation, telles que les groupes d'attente et les exclusions mutuelles.

Pour cet article, nous ne sommes intéressés que par les serrures d'exclusions mutuelles ou Mutex pour faire court. Le package de synchronisation nous fournit deux méthodes pour implémenter Mutex dans les programmes Go:

1. Serrure()
2. Ouvrir()

Si vous placez un code entre les méthodes de verrouillage et de déverrouillage, les programmes GO permettra uniquement un seul thread ou Goroutine pour accéder à ce code.

Prenons un programme simple avec des conditions de course:

package principal
importer (
"FMT"
"sync"
)
var x = 1
func add (wg * sync.WaitGroup)
X++
wg.Fait()

func main ()
Var WaitGroup Sync.Groupe d'attente
pour i: = 0; je < 10000; i++
groupe d'attente.Ajouter (1)
Allez ajouter (et WaitGroup)

groupe d'attente.Attendez()
fmt.Println (x)

Dans l'exemple précédent, nous avons une fonction qui prend la valeur de x et l'incrémente par 1. La fonction indique ensuite au groupe d'attente de débloquer le mécanisme d'attente à l'aide de la fonction Done ().

À l'intérieur de la fonction principale, nous exécutons au moins 10 000 Goroutines simultanément, chacun essayant d'accéder et de modifier la valeur de x.

Puisqu'il n'y a pas d'ordre déterministe pour exécuter les Goroutines, la valeur (augmentation de la valeur de x) de x change à chaque cycle.

Pour résoudre pour la condition de course précédente, nous pouvons utiliser un mutex comme indiqué ci-dessous:

package principal
importer (
"FMT"
"sync"
)
var x = 1
func add (wg * sync.WaitGroup, MX * Sync.Mutex)
// verrouiller l'accès à cette valeur
mx.Serrure()
X++
mx.Ouvrir()
wg.Fait()

func main ()
Var WaitGroup Sync.Groupe d'attente
Var Mutex Sync.Muex
pour i: = 0; je < 10000; i++
groupe d'attente.Ajouter (1)
Allez ajouter (et WaitGroup, & mutex)

groupe d'attente.Attendez()
fmt.Println (x)

Ici, nous ajoutons MX de la synchronisation.Mutex à la fonction ajouter. Ensuite, nous verrouillons l'opérateur d'incrément pour permettre une seule goroutine à la fois.

Fermeture

Cet article couvrait les principes fondamentaux de la mise en œuvre d'un mutex en Go en utilisant le package de synchronisation pour réparer une condition de course simple. Nous espérons que vous avez trouvé cet article utile. Consultez d'autres articles sur les conseils Linux pour plus de conseils et d'informations.