Linux读写锁相关函数及操作

读写锁：

概念：读写锁也叫共享-独占锁。当读写锁以读模式锁住时，它是以共享模式锁住的；当它以写模式锁住时，它是以独占模式锁住的。（写独占，读共享）。

读写锁使用场所：

读写锁非常适合对数据结构读的次数远大于写的情况（可以同时读）

特性：

读写锁是“写模式加锁”时，解锁前，所有对该锁加锁的线程都会被阻塞；

读写锁是“读模式加锁”时，如果线程以读模式对其加锁就会成功；如果线程以写模式加锁会阻塞；

读写锁是“读模式加锁”时，既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式加锁，优先满足写模式加锁。读锁，写锁并行阻塞，写锁优先级高。

例如：

线程A加写锁成功，线程B请求读锁

->B锁阻塞，等A解锁后，B加锁成功

线程A加读锁成功，线程B请求写锁

->B锁阻塞，等A解锁后，B加锁成功

线程A拥有读锁，线程B请求B锁

->线程B加锁成功

线程A持有读锁，然后线程B请求写锁，然后线程C请求读锁

->线程B和C都阻塞；

->当A释放锁之后，B先获得锁，C阻塞；

->当B释放锁后，C获得锁；

线程A持有读锁，然后线程B请求读锁，然后线程C请求写锁

->线程B获得锁成功，线程C要等AB释放锁后才能获得锁

线程A持有写锁，然后线程B请求读锁，然后线程C请求写锁

->线程B和C都阻塞；

->当A释放锁之后，C先获得锁，B阻塞；

->当C释放锁后，B获得锁；

读写锁相关函数：

pthread_rwlock_t函数：

函数描述:定义一把锁；

pthread_rwlock_init函数：

函数描述：初始化读写锁

函数原型：int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
const pthread_rwlockattr_t *restrict attr);

函数参数：rwlock-读写锁 attr-读写锁属性，传NULL

pthread_relock_destroy函数：

函数描述：销毁锁；

函数原型：int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

pthread_rwlock_rdlock函数：

函数描述：加读锁

函数原型：int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

pthread_rwlock_tryrdlock函数：

函数描述：尝试加读锁，不会阻塞；

函数原型：int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

pthread_rwlock_wrlock函数：

函数描述：加写锁；

函数原型：int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

pthread_rwlock_trywrlock函数：

函数描述：尝试加写锁，不会阻塞；

函数原型：int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

pthread_rwlock_unlock函数：

函数描述：解锁；

函数原型： int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

案例：

创建3个线程写共享资源，五个线程读共享资源

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<pthread.h>
int num=1;
//定义一把锁
pthread_rwlock_t rwlock;
void * thread_w(void *arg)
{
	int n=*(int *)arg;
	int i=0;
	for(;i<10;i++)
	{
		pthread_rwlock_wrlock(&rwlock);
		num++;
		printf("[%d]write num=[%d]\n",n,num);
		pthread_rwlock_unlock(&rwlock);
	}
}
void *thread_r(void *arg)
{
	int n=*(int *)arg;
	pthread_rwlock_rdlock(&rwlock);
	printf("[%d]read num==[%d]\n",n,num);
	pthread_rwlock_unlock(&rwlock);
}
int main()
{
	pthread_rwlock_init(&rwlock,NULL);//初始化锁
	pthread_t thread[8];
	int arr[8];
	int i=0;
	for(;i<3;i++)
	{
		arr[i]=i;
		pthread_create(&thread[i],NULL,thread_w,&arr[i]);
	}
	for(;i<8;i++)
	{
		arr[i]=i;
		pthread_create(&thread[i],NULL,thread_r,&arr[i]);
	}
	int j=0;
	for(;j<8;j++)
	{
		pthread_join(thread[j],NULL);
	}
	pthread_rwlock_destroy(&rwlock);//销毁锁
	printf("final num==[%d]\n",num);
	return 0;
}

结果：