Explication détaillée des verrous fournis dans le package de synchronisation et de leurs méthodes de mise en œuvre

En programmation concurrente, les verrous sont un outil important pour résoudre les conflits d'accès aux ressources partagées. L'implémentation du verrouillage dans le package de synchronisation fourni dans le langage Go constitue une partie importante de sa programmation simultanée. Cet article présentera les verrous fournis dans le package de synchronisation et leurs méthodes de mise en œuvre pour aider les lecteurs à mieux comprendre le mécanisme de verrouillage dans la programmation simultanée.

1. Implémentation du verrouillage dans le package de synchronisation

Le package de synchronisation fournit trois types de verrous : mutex (Mutex), verrouillage en lecture-écriture (RWMutex) et groupe d'attente (WaitGroup). Leurs méthodes de mise en œuvre seront présentées séparément ci-dessous.

1. Mutex (Mutex)

Mutex est la forme de verrouillage la plus basique, utilisée pour protéger l'accès simultané aux ressources partagées. L'utilisation d'un verrou mutex permet à une seule goroutine d'accéder à une ressource partagée, garantissant ainsi un accès sécurisé à la ressource. La méthode d'implémentation du verrouillage mutex peut faire référence au code suivant :

var mu sync.Mutex
var count int

func main() {
    for i := 0; i<10; i++ {
        go func(){
            mu.Lock()
            defer mu.Unlock()

            count++
            fmt.Println(count)
        }()
    }

    time.Sleep(time.Second)
}

Dans le code ci-dessus, nous utilisons les méthodes Lock et Unlock de type sync.Mutex pour protéger l'accès simultané à la variable count. En appelant la méthode Lock, vous pouvez obtenir un verrou mutex pour contrôler le nombre d'accès simultanés à la ressource. Après avoir exécuté la logique appropriée, vous devez appeler la méthode Unlock pour libérer le verrou mutex.

2. Verrouillage en lecture-écriture (RWMutex)

Le verrouillage en lecture-écriture est un verrou conçu pour résoudre le problème de plus de lecture et moins d'écriture. Dans les scénarios où il y a beaucoup de lectures et peu d'écritures, le coût d'utilisation d'un mutex est relativement élevé, car le verrouillage n'est pas requis lors de la lecture des ressources partagées. Lorsque le thread d'écriture modifie directement les ressources, le verrouillage est requis.

Par conséquent, l'utilisation de verrous en lecture-écriture peut améliorer la simultanéité du programme. Voici un exemple d'utilisation d'un verrou en lecture-écriture :

var rw sync.RWMutex
var count int

func main() {
    for i := 0; i<10; i++ {
        go func(){
            rw.RLock()
            defer rw.RUnlock()

            fmt.Println(count)
        }()
    }

    time.Sleep(time.Second)
}

Dans le code ci-dessus, nous utilisons les méthodes RLock et RUnlock de type sync.RWMutex pour écrire des opérations de lecture sur des ressources partagées, tandis que les opérations d'écriture utilisent le type Mutex. Méthode de verrouillage et de déverrouillage.

Il convient de noter que si le verrou de lecture est déjà occupé, alors le verrou d'écriture doit attendre que tous les verrous de lecture soient libérés avant de pouvoir être acquis, et il doit également attendre que le verrou d'écriture actuel soit libéré avant il peut acquérir le verrou de lecture. Par conséquent, lorsque vous utilisez des verrous en lecture-écriture, vous devez réfléchir à la manière de les utiliser en fonction de la situation spécifique.

3. Wait Group (WaitGroup)

Wait group est un outil pratique qui permet à plusieurs goroutines d'attendre la fin ensemble.

Le groupe d'attente est initialisé avec une valeur de zéro, des goroutines peuvent être ajoutées et supprimées, et lorsque son compteur interne atteint zéro, toutes les goroutines bloquantes et en attente seront réveillées. Dans le code suivant, nous utilisons les méthodes Add et Done du groupe en attente pour contrôler le nombre de goroutines :

var wg sync.WaitGroup

func main() {
    for i := 0; i<10; i++ {
        wg.Add(1)
        go func(){
            defer wg.Done()

            fmt.Println("goroutine")
        }()
    }

    wg.Wait()
    fmt.Println("finished")
}

Dans le code ci-dessus, nous utilisons d'abord la méthode Add pour ajouter 10 goroutines au groupe en attente, puis exécutons la logique pertinente une fois qu'ils ont terminé. Enfin, utilisez la méthode Done pour réduire le compteur de groupes en attente. À la fin, utilisez la méthode wg.Wait() pour attendre que tous les compteurs du groupe d'attente soient effacés.

2. Résumé

Cet article présente les méthodes d'implémentation de verrouillage fournies dans le package de synchronisation en langage Go, y compris les verrous mutex, les verrous en lecture-écriture et les groupes d'attente. Ces verrous sont des outils de base dans la programmation simultanée en langage Go et jouent un rôle important dans le contrôle de l'accès aux ressources et dans l'augmentation de la simultanéité des programmes. En apprenant à les utiliser, nous pouvons mieux comprendre le mécanisme de verrouillage dans la programmation simultanée et écrire des programmes simultanés plus efficaces et plus sûrs.

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!