Golang Sync

Le package de synchronisation Golang fournit des primitives de synchronisation, telles que Mutex, Waitgroup, Pool, Read and Write Mutex et Condition Variables.

Explorons certaines fonctionnalités fournies dans cet article.

Golang Mutex

La synchronisation.Mutex fournit une primitive mutex, ce qui permet des exclusions mutuelles pour les ressources partagées empêchant les conditions de course.

Exemple d'utilisation:

package principal
Importer "Sync"
func main ()
var i = 10
mutex: = & sync.Mutex
muex.Serrure()
// Un seul goroutine peut accéder à ce code à la fois
je++
muex.Ouvrir()

Lire / écrire Mutex

La synchronisation.RWMutex fournit un lecteur / écrivain Mutex. Il offre des méthodes similaires en tant que mutex primitif mais peut permettre des lectures simultanées en utilisant des méthodes RLOCK et Runlock:

var i = 10
mutex: = & sync.Rwmutex
muex.Serrure()
// Un seul goroutine peut accéder à ce code à la fois
je++
muex.Ouvrir()
muex.Rlock ()
I ++ // lectures simultanées
muex.Runlock ()

L'exemple précédent peut permettre à un Goroutine de lire le code. Contrairement à la synchronisation.Mutex, qui permet exactement un lecteur et un écrivain à la fois.

Groupes d'attente

La synchronisation.Waitgroup est utilisé pour offrir un mécanisme de blocage pour les goroutines. À l'aide d'un groupe d'attente, vous pouvez bloquer l'exécution d'une fonction jusqu'à ce que tous les Goroutines aient fini l'exécution.

Il fonctionne en créant un compteur qui contient le nombre de Goroutines à attendre. Une fois une goroutine terminée, le compteur diminue de 1. Une fois que le compteur est 0, le groupe d'attente débloque l'exécution.

Pour ajouter une valeur au compteur de groupe d'attente, nous pouvons utiliser la méthode Add (), qui prend une valeur entière.

Pour éliminer un goroutine du comptoir après l'achèvement, nous utilisons la méthode Done (). Par exemple:

package principal
importer (
"FMT"
"sync"
)
func main ()
wg: = & sync.WaitGroup
pour i: = 0; je < 5; i++
wg.Ajouter (1)
aller func (x int)
fmt.Printf ("Worker:% D Running \ n", x)
wg.Fait()
(je)

wg.Attendez()

Dans l'exemple précédent, nous incrémentons la valeur du compteur de groupe d'attente par 1 via l'utilisation de la fonction add ().

Une fois une goroutine terminée, nous décrémentons le compteur par 1 en utilisant la méthode Done (). Le code précédent doit renvoyer la sortie comme suit:

Travailleur: 4 Running
Travailleur: 2 Running
Travailleur: 1 Running
Travailleur: 3 Courir
Travailleur: 0 Running

Une fois

La synchronisation.Une fois primitif garantit qu'une fonction ne fonctionne qu'une seule fois. Un exemple est comme indiqué ci-dessous:

var une fois la synchronisation.Une fois
Runonce: = func ()
fmt.Println ("Run une fois")

fait: = make (chan string)
pour i: = 0; je < 5; i++
aller func ()
une fois.Faire (Runonce)
fait <- "Hi"
()

pour i: = 0; je < 5; i++
<-done

Conclusion

Ce guide couvre certaines primitives de base et fondamentales fournies par le package Go Sync. De plus, les primitives de synchronisation, telles que Mutex, Waitgroup, Pool, Read and Write Mutex et les variables de condition, ont été discutées. Nous espérons que vous avez trouvé cet article utile. Découvrez d'autres articles sur les conseils pour plus de conseils et de tutoriels.