Pendant le développement de LiveAPI, un outil de génération de documentation API Auto, j'avais besoin d'implémenter un mécanisme de file d'attente robuste qui a mis à l'échelle en fonction du nombre de cœurs de machine serveur. Cela a été crucial pour empêcher une utilisation excessive des ressources (mémoire et CPU) qui pouvaient conduire à la famine des ressources, aux plantages et à une mauvaise expérience utilisateur.

Dans cet article, je vais expliquer comment j'ai utilisé des mutexes à Golang pour relever ce défi.

Qu'est-ce qu'un mutex?
Dans la programmation simultanée, un mutex (exclusion mutuelle) est un mécanisme de verrouillage qui empêche les conditions de course en garantissant qu'un seul goroutine peut accéder à une ressource partagée à la fois. Cela s'apparente à une clé d'une pièce - une seule personne peut tenir la clé et entrer en même temps.

usage mutex dans golang
Illustrons comment un mutex peut gérer l'exécution de l'emploi simultanée:
Le package de synchronisation de Go fournit plusieurs primitives pour la synchronisation, Mutex étant l'un des outils les plus couramment utilisés.

var (
    maxConcurrentJobs int
    activeJobs        int
    jobMutex          sync.Mutex
)

Dans ce code, la variable ActiveJobs suit le nombre de travaux en cours d'exécution. Étant donné que plusieurs Goroutines pourraient tenter de modifier cette variable simultanément, conduisant à des conditions de course, nous utilisons un mutex pour synchroniser l'accès.

// Check if we can process more jobs
jobMutex.Lock()
if activeJobs >= maxConcurrentJobs {
    jobMutex.Unlock()
    // Wait before checking again
    time.Sleep(time.Second)
    continue
}
jobMutex.Unlock()

comment un mutex fonctionne
verrouillage : la méthode Lock () acquiert un accès exclusif à la section critique.

déverrouillage : la méthode llock () libère le verrou.

Section critique : le code entre verrouillage et déverrouiller où la ressource ** partagée est accessible.

Types de mutexes dans golang
sync.mutex : Il s'agit du verrouillage d'exclusion mutuel de base dans Go. Il ne permet qu'un seul Goroutine d'accéder à la section critique à la fois.

type SafeCounter struct {
    mu    sync.Mutex
    count int
}

sync.rwmutex : il s'agit d'un lecteur / écrivain mutex qui permet à plusieurs lecteurs d'accéder simultanément à la ressource partagée, mais un seul écrivain à la fois.

var rwMutex sync.RWMutex
// Reader methods
rwMutex.RLock()   // Lock for reading
rwMutex.RUnlock() // Unlock for reading

// Writer methods
rwMutex.Lock()    // Lock for writing
rwMutex.Unlock()  // Unlock for writing

Les mutex sont des outils essentiels pour gérer les ressources partagées dans des programmes GO simultanés. Ils empêchent les conditions de course et garantissent l'intégrité des données en contrôlant l'accès aux sections critiques de code.