Linux多线程基础(5):读写锁(rwlock大白话讲解)

前文中已经介绍了互斥锁用于解决数据共享带来的问题,为什么又要引入读写锁呢?别慌,我将用最通俗的解释来帮助大家理解!

1.为什么要引入读写锁

假设我们对一个线程使用了互斥锁,一旦上锁,其他线程对共享数据既不能读取,也不能写入.聪明的你可能会发现:如果大部分线程仅仅想读取共享数据,这一上互斥锁,都得等该线程完成并解锁后才可以读取数据,效率可谓是大大降低了呀!

为了解决上述面临的问题,读写锁诞生了!

2.读写锁的定义

读写锁（pthread_rwlock_t）是一种线程同步机制，允许多个线程对同一共享资源进行读操作，但同一时间只允许有一个线程对共享数据进行写操作。

读写锁共有两种操作:pthread_rwlock_rdlock(读锁)和pthread_rwlock_wrlock(写锁)

2.1 pthread_rwlock_rdlock(读锁)

读锁是用来给读操作加锁的。当一个进程给共享资源加上读锁后,其他线程仍然可以给共享资源加读锁,并可以成功读取数据,但是不能加写锁.读锁的定义如下:

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

其中参数rwlock为指向pthread_rwlock_t类型的指针。若函数成功执行,返回0,失败返回错误码.

举个例子:我先讲解一个这段代码的主要意思,代码中一共有两个线程,线程1线程2都加了读锁,目的是看看在加了读锁后是否会出现线程1线程2交替进行读操作的情况.

#include <pthread.h>  
#include<string.h>  
#include<stdio.h>  
#include<unistd.h>  
#include<stdlib.h>  
#include<iostream>  
int number=10;//全局变量
pthread_rwlock_t rwlock; 
void *pth1(void* str){
    pthread_rwlock_rdlock(&rwlock);//加读锁
       for(int i=0;i<10;i++){
        std::cout<<"线程1加读锁输出结果:"<<number<<std::endl;
        usleep(10);
    } 
    pthread_rwlock_unlock(&rwlock);   //解读锁
    pthread_exit(0);
}
void *pth2(void* str){
    pthread_rwlock_rdlock(&rwlock);//加读锁
     for(int i=0;i<10;i++){
        std::cout<<"线程2加读锁输出结果:"<<number<<std::endl;  //检测是否可以读取到数据
     }
    usleep(5);
    pthread_rwlock_unlock(&rwlock);   //解读锁
    pthread_exit(0); 
}
int main(void){
    pthread_t thread1,thread2;
    pthread_rwlock_init(&rwlock,NULL);  //读写锁初始化
    pthread_create(&thread1,NULL,pth1,NULL);
    pthread_create(&thread2,NULL,pth2,NULL);
    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    pthread_rwlock_destroy(&rwlock);  //读写锁销毁
    std::cout<<"主函数退出"<<std::endl;
}  

?运行程序得到下面的结果:

可以看出, 线程1线程2出现了交替进行读操作的情况.说明读写锁允许多个线程对同一共享资源进行读操作.

2.2pthread_rwlock_wrlock(写锁)

写锁是用来给写操作加锁的。当一个线程给共享资源加上写锁后,其他线程既不可加读锁也不能加写锁,其实就相当于是一个互斥锁.写锁的定义如下:

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

其中参数rwlock为指向pthread_rwlock_t类型的指针。若函数成功执行,返回0,失败返回错误码.

举个例子:我先讲解一个这段代码的主要意思,代码中一共有两个线程,线程1加了写锁,线程2加了读锁,目的是看看在加了写锁的情况下是否可以进行读操作.

#include <pthread.h>  
#include<string.h>  
#include<stdio.h>  
#include<unistd.h>  
#include<stdlib.h>  
#include<iostream>  
int number;//全局变量
pthread_rwlock_t rwlock; 
void *pth1(void* str){
    pthread_rwlock_wrlock(&rwlock);//加写锁
       for(int i=0;i<20;i++){
        number++;
        std::cout<<"线程1加写锁输出结果:"<<number<<std::endl;
        usleep(10);
    } 
    pthread_rwlock_unlock(&rwlock);   //解读锁
    pthread_exit(0);
}
void *pth2(void* str){
    pthread_rwlock_rdlock(&rwlock);//加读锁
    std::cout<<"线程2加读锁输出结果:"<<number<<std::endl;  //检测是否可以读取到数据

    usleep(5);
    pthread_rwlock_unlock(&rwlock);   //解读锁
    pthread_exit(0); 
}
int main(void){
    pthread_t thread1,thread2;
    pthread_rwlock_init(&rwlock,NULL);  //读写锁初始化
    pthread_create(&thread1,NULL,pth1,NULL);
    pthread_create(&thread2,NULL,pth2,NULL);
    pthread_join(thread1,NULL);
    pthread_join(thread2,NULL);
    pthread_rwlock_destroy(&rwlock);  //读写锁销毁
    std::cout<<"主函数退出"<<std::endl;
}  

运行程序得到下面的结果:

?可以看出,只有当线程1完成所有任务,并对写锁解锁后,线程2才能进行读操作!

3.总结

当一个多线程程序中,读操作比较多时,我们这时就使用读写锁,写操作比较多时,就用互斥锁即可.