这里写目录标题

• 读写锁的认识
• 读写锁的相关函数
• 练习

读写锁的认识

（1）读写锁是一把锁
（2）读写锁的类型： pthread_rwlock_t lock 又分“读锁”（对内存进行读操作）和“写锁”（对内存进行写操作）
（3）读写锁的特性：
1）读共享-并行处理：例如，线程 A 加读锁成功，有来个 3 个线程，作读操作，也可加锁成功。
2）写独占-串行处理：例如，线程 A 加写锁成功，有来个 3 个线程，作读操作，3 个线程阻塞。
3） 读写不能同时进行，写的优先级高：例如，线程A加读锁成功，又来了B线程加写锁阻塞，又来了C线程加读锁阻塞
（4）读写锁的场景练习：
1）线程 A 加写锁成功，线程 B 请求读锁 ：B 读阻塞。
2）线程 A 加读锁成功，线程 B 请求写锁 ：B 写阻塞。
3）线程 A 加读锁成功，线程 B 请求读锁 ：线程 B 加读锁成功。
4）线程 A 加读锁成功，然后线程 B 请求写锁，然后线程 C 请求读锁 ：B 写阻塞，C 读阻塞；
A 解锁 ：B 加写锁成功，C 继续读阻塞 ；
B 解锁 ：C 加读锁成功。
5）线程 A 加读写成功，然后线程 B 请求读锁，然后线程 C 请求写锁 ：B 读阻塞，C 写阻塞；
A 解锁 ：C 加写锁成功，B 继续读阻塞；
C 解锁 ：B 加读锁成功。
（5）读写锁与互斥锁的区别
互斥锁 ： 读写串行 。
读写锁 ： 读并行，写串行。
读写锁更关注“读并行”，如果关注串行，那直接用互斥锁好了，所以读写锁更适用于读操作多的场景，通过其并行的特性，可以提高效率。

读写锁的相关函数

初始化读写锁

pthread_rwlock_init(pthread_rwlock_t* restrict rwlock,const pthread_rwlockattr_t* restrict attr );

销毁读写锁

pthread_rwlock_destroy(pthread_rwlock_t* rwlock):

加读锁

pthread_rwlock_rdlock(pthread_rwlock_t* rdlock);

阻塞：之前对这把锁加的是写锁的操作
尝试加读锁

pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);

加锁成功：返回0
失败：返回错误号
加写锁

pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);

阻塞：上一次加写锁还没解锁
阻塞：上一次加读锁还没解锁
尝试加写锁

pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);

解锁

pthread_rwlock_unlock(pthread_rwlock_t* rwlock)

练习

三个线程不定时写同一个全局变量，五个线程不定时期读同一全局资源
先不加锁：

#include 
#include 
#include int number=0;
pthread_rwlock_t rwlock;
void *write_pthread(void * arg)
{while(1){//pthread_rwlock_wrlock(&rwlock);number++;printf("write_pthread id:%ld, number is %d\n",pthread_self(),number);usleep(500);//pthread_rwlock_unlock(&rwlock);}
}
void *read_pthread(void * arg)
{while(1){//pthread_rwlock_wrlock(&rwlock);printf("read_pthread id: %ld,number is %d\n",pthread_self(),number);usleep(500);//pthread_rwlock_unlock(&rwlock);}
}int main()
{pthread_t p[8];pthread_rwlock_init(&rwlock,NULL);for(int i=0;i<3;i++){pthread_create(&p[i],NULL,write_pthread,NULL);}for(int i=3;i<8;i++){pthread_create(&p[i],NULL,read_pthread,NULL);}for(int j=0;j<8;j++){pthread_join(p[j],NULL);}return 0;
}

截取结果片段：

发现读的number值有时会小于写的number值，这因为没加读写锁时，读和写线程都是并发执行，会引发混乱。

加读写锁：

#include 
#include 
#include int number=0;
pthread_rwlock_t rwlock;
void *write_pthread(void * arg)
{while(1){       //加写锁pthread_rwlock_wrlock(&rwlock);number++;printf("write_pthread id:%ld, number is %d\n",pthread_self(),number);pthread_rwlock_unlock(&rwlock);//解锁sleep(1);}
}
void *read_pthread(void * arg)
{while(1){       //加读锁pthread_rwlock_wrlock(&rwlock);printf("read_pthread id: %ld,number is %d\n",pthread_self(),number);pthread_rwlock_unlock(&rwlock);//解锁sleep(1);}
}int main()
{pthread_t p[8];pthread_rwlock_init(&rwlock,NULL);for(int i=0;i<3;i++){pthread_create(&p[i],NULL,write_pthread,NULL);}for(int i=3;i<8;i++){pthread_create(&p[i],NULL,read_pthread,NULL);}for(int j=0;j<8;j++){pthread_join(p[j],NULL);}return 0;
}

执行结果：

可以看到加了读写锁以后，读是并行的，写串行的，number的顺序是由小到大，不会发生混乱。