implémentation du verrouillage en lecture-écriture Golang

Golang est un langage de programmation moderne très populaire qui prend en charge le développement d'applications à haute concurrence et hautes performances. Dans Golang, le verrouillage en lecture-écriture est un mécanisme de synchronisation courant qui permet à plusieurs coroutines de lire des variables partagées en même temps, mais qui permet à une seule coroutine d'écrire des variables partagées. Dans cet article, nous présenterons comment implémenter le verrouillage en lecture-écriture à l'aide de Golang.

Principe de base du verrouillage en lecture-écriture

Le verrouillage en lecture-écriture est un mécanisme de synchronisation qui permet à plusieurs coroutines de lire des variables partagées en même temps, mais qui ne permet qu'à une seule coroutine d'écrire des variables partagées. Les verrous en lecture-écriture peuvent améliorer efficacement les performances de concurrence car ils permettent à plusieurs coroutines de lire les variables partagées en même temps, réduisant ainsi le nombre de conflits et de conflits de verrouillage.

Les verrous en lecture-écriture ont deux états : lecture et écriture. Dans l'état de lecture, plusieurs coroutines peuvent lire les variables partagées en même temps, tandis que dans l'état d'écriture, une seule coroutine est autorisée à écrire des variables partagées. La transition d'état des verrous en lecture-écriture inclut les situations suivantes :

1. Verrouillage en lecture : plusieurs coroutines peuvent acquérir des verrous en lecture en même temps, mais ne peuvent pas acquérir de verrous en écriture.

2. Verrouillage en écriture : une seule coroutine peut acquérir le verrou en écriture, et les autres coroutines ne peuvent pas acquérir le verrou en lecture ni le verrou en écriture.

3. Déverrouillage : toutes les coroutines peuvent libérer les verrous de lecture et les verrous d'écriture.

Voyons maintenant comment utiliser Golang pour implémenter des verrous en lecture-écriture.

Implémentation du code

La bibliothèque standard Golang a fourni l'implémentation de verrous en lecture-écriture. Nous pouvons directement utiliser la structure RWMutex dans le package de synchronisation pour implémenter des verrous en lecture-écriture.

Tout d'abord, jetons un œil à la définition de la structure RWMutex :

tapez RWMutex struct {

 //包含隐藏或非导出字段

}

RWMutex contient un champ caché ou non exporté. Il propose les trois méthodes suivantes :

1.RLock : acquérir le verrou de lecture

func (rw *RWMutex) RLock()

2.RUnlock : libérer le verrou de lecture

func (rw *RWMutex) RUnlock()

3.Lock : Acquérir le verrou en écriture

func (rw *RWMutex) Lock()

4.Unlock : Libérer le verrou en écriture

func (rw *RWMutex) Unlock()

Ci-dessous, nous passons un exemple simple à montrez comment utiliser RWMutex pour implémenter le verrouillage en lecture-écriture :

package main

import (

"fmt"
"sync"

)

var (

count int
rw sync.RWMutex

)

func main() {

for i := 0; i < 10; i++ {
    go read(i)
}
for i := 0; i < 5; i++ {
    go write(i)
}
fmt.Scanln()

}

func read(n int ) {

rw.RLock()
fmt.Println("读取协程", n, "开始读取数据")
v := count
fmt.Println("读取协程", n, "读取数据为:", v)
rw.RUnlock()

}

func write(n int) {

rw.Lock()
fmt.Println("写入协程", n, "开始写入数据")
count++
v := count
fmt.Println("写入协程", n, "写入数据为:", v)
rw.Unlock()

}

Dans le code, nous définissons un nombre de variables partagées et un objet RWMutex rw. Nous avons créé 10 coroutines de lecture et 5 coroutines d'écriture, et lu et écrit des variables partagées dans ces coroutines.

Dans la fonction de lecture, nous utilisons la méthode RLock pour acquérir le verrou de lecture, lire la variable partagée et utiliser la méthode RUnlock pour libérer le verrou de lecture une fois la lecture terminée. Dans la fonction d'écriture, nous utilisons la méthode Lock pour acquérir le verrou en écriture, écrivons dans la variable partagée et utilisons la méthode Unlock pour libérer le verrou en écriture une fois l'écriture terminée.

Après avoir exécuté le code, vous pouvez voir que plusieurs coroutines lisent et écrivent simultanément des variables partagées, mais une seule coroutine peut écrire dans les variables partagées.

Résumé

Dans cet article, nous avons présenté comment implémenter des verrous en lecture-écriture à l'aide de Golang. Nous utilisons la structure RWMutex dans le package de synchronisation pour implémenter des verrous en lecture-écriture et contrôler la lecture et l'écriture des variables partagées à accès simultané via les méthodes RLock, RUnlock, Lock et Unlock. L'implémentation de verrous en lecture-écriture permet à plusieurs coroutines de lire simultanément les variables partagées, améliorant ainsi les performances et réduisant le nombre de conflits et de conflits de verrouillage.

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!