introduction
Cet article est le treizième article, le verrou en lecture-écriture de la synchronisation des threads. Le verrouillage en lecture- écriture est également l'une des méthodes pour résoudre la synchronisation des threads. Dans les deux articles précédents, la Chine a introduit deux méthodes d'exclusion mutuelle et de verrouillage de rotation. Le principe du verrou lecture-écriture est similaire aux deux verrous précédents, mais le verrou lecture-écriture a apporté quelques améliorations
Verrou en lecture-écriture
L'amélioration des verrous en lecture-écriture est considérée à partir des points suivants, dont le plus important est la prise en compte des ressources critiques. Dans un environnement de développement complexe, il y aura probablement plus de lecture et moins d'écriture de ressources critiques . Par exemple, une table dans une base de données stocke principalement des données historiques. Pour ces données historiques, les requêtes sont généralement effectuées et rarement modifiées. La table qui stocke les données historiques est alors une ressource critique avec plus de lecture et moins d'écriture. Pour la lecture, la valeur de la ressource critique ne sera pas modifiée . Si nous la verrouillons à chaque lecture ou écriture, l'efficacité est très faible. Donc, à ce moment, nous devrions nous demander s'il existe une méthode plus efficace? À ce stade, un verrou en lecture-écriture est généré
Introduction aux verrous en lecture-écriture
- Le verrou en lecture-écriture est un verrou rotatif spécial
- Autoriser plusieurs lecteurs à accéder aux ressources en même temps pour améliorer les performances de lecture
- Il est mutuellement exclusif pour les opérations d'écriture (plusieurs opérations d'écriture ne sont pas autorisées à accéder à la même ressource en même temps)
À propos du modèle de verrouillage en lecture-écriture
Pour un verrou en lecture-écriture, il permet à plusieurs lecteurs de lire des ressources critiques en même temps , de sorte que les threads de lecteur 1, 2 et 3 de la figure ci-dessous peuvent lire les ressources critiques en même temps, mais lors de la lecture, il ne le sera pas. permettre aux opérations d'écriture d'accéder aux ressources critiques. Étant donné que la ressource critique n'est pas modifiée lors de la lecture et que l'opération d'écriture peut changer la valeur de la ressource critique, dans le verrou de lecture-écriture, la lecture et l'écriture sont mutuellement exclusives, et la lecture et la lecture ne s'excluent pas mutuellement
Exemple de verrouillage en lecture-écriture
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<vector>
//临界资源
int num=0;
//定义读写锁
pthread_rwlock_t relock=PTHREAD_RWLOCK_INITIALIZER;
void *reader(void*){
int times=10000000;
while(times--){
//在读操作之前加读锁
pthread_rwlock_rdlock(&rdlock);
if(times%1000==0){
usleep(10);
}
//释放读锁
pthread_rwlock_unlock(&rdlock);
}
}
void *writer(void*){
int times=10000000;
while(times--){
//加写锁
pthread_rwlock_wrlock(&rdlock);
num+=1;
pthread_rwlock_unlock(&rdlock);
}
}
int main()
{
printf("Start in main function.");
//定义三个线程
pthread_t thread1,thread2, thread3;
//两个执行读操作，一个执行写操作
pthread_create(&thread1, NULL, &reader, NULL);
pthread_create(&thread2, NULL, &reader, NULL);
pthread_create(&thread3, NULL, &writer, NULL);
pthread_join(&thread1, NULL);
pthread_join(&thread2, NULL);
pthread_join(&thread3, NULL);
//打印临界资源的值
printf("Print in main function: num = %d\n", num);
return 0;
}
Comme mentionné ci-dessus, le verrou en lecture-écriture aura une amélioration significative des performances en cas de lecture et d'écriture plus faibles . À ce stade, vous pouvez le vérifier. Exécutez le programme du verrou de lecture-écriture utilisé ci-dessus et vérifiez la durée d'exécution comme suit:
Maintenant, remplacez le verrou en lecture-écriture par un mutex, puis regardez l'heure d'exécution
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<vector>
//临界资源
int num=0;
//初始化互斥量
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
//定义读写锁
//pthread_rwlock_t relock=PTHREAD_RWLOCK_INITIALIZER;
void *reader(void*){
int times=10000000;
while(times--){
//在读操作之前加读锁
//pthread_rwlock_rdlock(&rdlock);
pthread_mutex_lock(&mutex);
if(times%1000==0){
usleep(10);
}
//释放读锁
//pthread_rwlock_unlock(&rdlock);
pthread_mutex_unlock(&mutex);
}
}
void *writer(void*){
int times=10000000;
while(times--){
//加写锁
//pthread_rwlock_wrlock(&rdlock);
pthread_mutex_lock(&mutex);
num+=1;
//pthread_rwlock_unlock(&rdlock);
pthread_mutex_unlock(&mutex);
}
}
int main()
{
printf("Start in main function.");
//定义三个线程
pthread_t thread1,thread2, thread3;
//两个执行读操作，一个执行写操作
pthread_create(&thread1, NULL, &reader, NULL);
pthread_create(&thread2, NULL, &reader, NULL);
pthread_create(&thread3, NULL, &writer, NULL);
pthread_join(&thread1, NULL);
pthread_join(&thread2, NULL);
pthread_join(&thread3, NULL);
//打印临界资源的值
printf("Print in main function: num = %d\n", num);
return 0;
}
Résultats du:
On peut voir que pour les ressources critiques avec plus de lectures et moins d'écritures, l'efficacité de l'utilisation des verrous de lecture-écriture est environ 5 fois supérieure à celle de l'utilisation de mutex
API pour la lecture et l'écriture de verrou en PHP: https://www.php.net/manual/zh/class.syncreaderwriter.php
C'est la compétitivité de base d'une personne technique pour trouver la constante dans la technologie en évolution rapide. Unité de connaissance et d'action, alliant théorie et pratique