Introducción
Este artículo es el decimotercer artículo, el bloqueo de lectura y escritura de la sincronización de subprocesos. El bloqueo de lectura y escritura también es uno de los métodos para resolver la sincronización de subprocesos. En los dos artículos anteriores, China ha introducido dos métodos de exclusión mutua y bloqueo de giro. El principio del bloqueo de lectura y escritura es similar a los dos bloqueos anteriores, pero el bloqueo de lectura y escritura ha realizado algunas mejoras.
Bloqueo de lectura y escritura
La mejora de los bloqueos de lectura-escritura se considera a partir de los siguientes puntos, el más importante de los cuales es la consideración de los recursos críticos. En un entorno de desarrollo complejo, es probable que haya más lectura y menos escritura de recursos críticos . Por ejemplo, una tabla en una base de datos almacena principalmente algunos datos históricos. Para estos datos históricos, las consultas se realizan generalmente y rara vez se modifican. Entonces, la tabla que almacena los datos históricos es un recurso crítico con más lectura y menos escritura. Para la lectura, el valor del recurso crítico no cambiará, si lo bloqueamos cada vez que leemos o escribimos, la eficiencia es muy baja. Entonces, en este momento, deberíamos considerar si existe un método más eficiente. En este momento, se genera un bloqueo de lectura-escritura.
Introducción a los bloqueos de lectura y escritura
- El bloqueo de lectura y escritura es un bloqueo de giro especial
- Permita que varios lectores accedan a los recursos al mismo tiempo para mejorar el rendimiento de lectura
- Es mutuamente excluyente para las operaciones de escritura (no se permite que varias operaciones de escritura accedan al mismo recurso al mismo tiempo)
Acerca del modelo de bloqueo de lectura y escritura
Para un bloqueo de lectura-escritura, permite que varios lectores lean recursos críticos al mismo tiempo , por lo que los hilos 1, 2 y 3 del lector en la figura siguiente pueden leer recursos críticos al mismo tiempo, pero mientras lee, no lo hará. permitir que las operaciones de escritura vayan Acceda a recursos críticos Debido a que el recurso crítico no cambia al leer, y la operación de escritura puede cambiar el valor del recurso crítico, en el bloqueo de lectura-escritura, la lectura y la escritura son mutuamente excluyentes, y la lectura y la lectura no son mutuamente excluyentes.
Ejemplo de bloqueo de lectura y escritura
#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;
}
Como se mencionó anteriormente, el bloqueo de lectura y escritura tendrá una mejora de rendimiento significativa en el caso de más lectura y menos escritura . En este momento, puede verificarlo. Ejecute el programa del bloqueo de lectura y escritura utilizado anteriormente y verifique el tiempo de ejecución. como sigue:
Ahora reemplace el bloqueo de lectura y escritura con un mutex, y luego observe el tiempo de ejecución
#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;
}
Resultados de:
Se puede ver que para recursos críticos con más lecturas y menos escrituras, la eficiencia de usar bloqueos de lectura y escritura es aproximadamente 5 veces mayor que la de usar mutex
API para lectura y escritura de bloqueo en PHP: https://www.php.net/manual/zh/class.syncreaderwriter.php
Es la competitividad central de una persona técnica encontrar la constante en la tecnología que cambia rápidamente. Unidad de conocimiento y acción, combinando teoría con práctica