关于读写锁以及用互斥锁和条件变量实现读写锁（写优先）

读写锁包括读取锁和写入锁，多个读线程可以同时访问共享数据；写线程必须等待所有读线程都释放锁以后，才能取得锁；同样的，读线程必须等待写线程释放锁后，才能取得锁；也就是说读写锁要确保的是如下互斥关系：可以同时读，但是读-写，写-写都是互斥的；明白这一点就很好做了。读写锁的分配规则：1.只要没有线程持有某个给定的读写锁用于写，那么任意数目的线程可以持有该读写锁写锁用于读。2.仅当没有线程持有某个给定的的读写锁用于读或者用于写时，才能分配该读写锁用于写。
通俗点说就是当没有写锁时，就可以加读锁且任意线程可以同时加，而写锁只能有一个，且必须在没有读锁时才能加上，一般来说，写锁优先。读写锁的数据类型为pthread_rwlock_t，可以用PTHREAD_RWLOCK_INITIALIZER来初始化。

#include<pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwptr);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwptr);
int pthread_rwlock_unlock(pthread_rwlock_t *rwptr);

以上三个基本函数返回值均：成功返回0，出错返回正的错误值；

#include<pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwptr);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwptr);

返回值同上；要注意的是，上面两个函数尝试获取一个读出锁或者写入锁，但是如果该锁不能马上获得，那就返回一个EBUSY错误，而不是把调用线程投入睡眠。

如何用互斥锁和条件变量实现读写锁呢？

以写锁优先为例：先定义基本的pthread_rwlock_t数据类型和操做读写锁的各个函数的函数原型，即my_pthread_rwlock.h头文件；

#pragma once

#include<pthread.h>
#include<stdio.h>
#include<errno.h>
#include<stdlib.h>
typedef struct
{
pthread_mutex_t rw_mutex;
pthread_cond_t  rw_condreaders;
pthread_cond_t  rw_condwriters;
int             rw_magic;
int             rw_nwaitreaders;
int             rw_nwaitwriters;
int             rw_refcount;       // 0 >0 ==-1
}my_pthread_rwlock_t;

#define  RW_MAGIC  0x19960511  //魔法数，可修改

#define MY_PTHREAD_RWLOCK_INITIALIZER {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER,\
RW_MAGIC,0,0,0}

typedef int  my_pthread_rwlockattr_t;

int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr);
int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw);
int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw);
int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw);
int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw);
int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw);
int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw);

函数实现部分：

#include"my_pthread_rwlock.h"

int my_pthread_rwlock_init(my_pthread_rwlock_t *rw, my_pthread_rwlockattr_t *attr)
{
int result;
if(attr != NULL)
return -1;

if((result = pthread_mutex_init(&rw->rw_mutex, NULL)) != 0)
goto err1;
if((result = pthread_cond_init(&rw->rw_condreaders, NULL)) != 0)
goto err2;
if((result = pthread_cond_init(&rw->rw_condwriters, NULL)) != 0)
goto e
4000
rr3;

rw->rw_nwaitreaders = 0;
rw->rw_nwaitwriters = 0;
rw->rw_refcount = 0;
rw->rw_magic = RW_MAGIC;
return 0;

err3:
pthread_cond_destroy(&rw->rw_condreaders);
err2:
pthread_cond_destroy(&rw->rw_mutex);
err1:
return result;
}

int my_pthread_rwlock_rdlock(my_pthread_rwlock_t *rw)
{
int result;
if(rw->rw_magic != RW_MAGIC)
return -1;
if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
return result;

while(rw->rw_refcount<0 || rw->rw_nwaitwriters>0)//在有写锁的条件下等待
{
rw->rw_nwaitreaders++;
result = pthread_cond_wait(&rw->rw_condreaders, &rw->rw_mutex);
rw->rw_nwaitreaders--;
if(result != 0)
break;
}
if(result == 0)
rw->rw_refcount++;
pthread_mutex_unlock(&rw->rw_mutex);
return result;
}

int my_pthread_rwlock_wrlock(my_pthread_rwlock_t *rw)
{
int result;
if(rw->rw_magic != RW_MAGIC)
return -1;

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
return result;

while(rw->rw_refcount != 0)//有锁时等待
{
rw->rw_nwaitwriters++;
result = pthread_cond_wait(&rw->rw_condwriters, &rw->rw_mutex);
rw->rw_nwaitwriters--;
if(result != 0)
break;
}
if(result == 0)
rw->rw_refcount = -1;

pthread_mutex_unlock(&rw->rw_mutex);
return result;
}

int my_pthread_rwlock_unlock(my_pthread_rwlock_t *rw)
{
int result;
if(rw->rw_magic != RW_MAGIC)
return -1;
if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
return result;

if(rw->rw_refcount > 0)
rw->rw_refcount--;
else if(rw->rw_refcount == -1)
rw->rw_refcount = 0;
else
printf("unlock error.\n");

if(rw->rw_nwaitwriters > 0)//写锁优先
{
if(rw->rw_refcount == 0)
{
result = pthread_cond_signal(&rw->rw_condwriters);
}
}
else if(rw->rw_nwaitreaders > 0)//唤醒读锁
result = pthread_cond_broadcast(&rw->rw_condreaders);

pthread_mutex_unlock(&rw->rw_mutex);
return result;
}

int my_pthread_rwlock_tryrdlock(my_pthread_rwlock_t *rw)
{
int result;
if(rw->rw_magic != RW_MAGIC)
return -1;

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
return result;

if(rw->rw_refcount < 0 || rw->rw_nwaitwriters > 0)
result = EBUSY;
else
rw->rw_refcount++;

pthread_mutex_unlock(&rw->rw_mutex);
return result;
}

int my_pthread_rwlock_trywrlock(my_pthread_rwlock_t *rw)
{
int result;
if(rw->rw_magic != RW_MAGIC)
return -1;

if((result = pthread_mutex_lock(&rw->rw_mutex)) != 0)
return result;

if(rw->rw_refcount != 0)
result = EBUSY;
else
rw->rw_refcount = -1;

pthread_mutex_unlock(&rw->rw_mutex);
return result;
}

int my_pthread_rwlock_destroy(my_pthread_rwlock_t *rw)
{
if(rw->rw_magic != RW_MAGIC)
return -1;
if(rw->rw_refcount != 0 || rw->rw_nwaitwriters != 0)
return EBUSY;

pthread_mutex_destroy(&rw->rw_mutex);
pthread_cond_destroy(&rw->rw_condreaders);
pthread_cond_destroy(&rw->rw_condwriters);
rw->rw_magic = 0;

return 0;
}

再是测试程序：

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include"my_pthread_rwlock.h"

my_pthread_rwlock_t rwlock = MY_PTHREAD_RWLOCK_INITIALIZER;

void * thread_fun1(void *arg)
{
my_pthread_rwlock_wrlock(&rwlock);
printf("thread 1 wrlock.\n");
sleep(3);
my_pthread_rwlock_unlock(&rwlock);
}
void * thread_fun2(void *arg)
{
my_pthread_rwlock_wrlock(&rwlock);
printf("thread 2 wrlock.\n");
my_pthread_rwlock_unlock(&rwlock);
}
void * thread_fun3(void *arg)
{
my_pthread_rwlock_rdlock(&rwlock);
printf("thread 3 rdlock.\n");
my_pthread_rwlock_unlock(&rwlock);
}

int main()
{
pthread_t tid1, tid2, tid3;
pthread_create(&tid1, NULL, thread_fun1, NULL);
sleep(1);
pthread_create(&tid3, NULL, thread_fun3, NULL);
pthread_create(&tid2, NULL, thread_fun2, NULL);

pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
pthread_join(tid3, NULL);

return 0;
}

结果：

这样子一个写优先的读写锁就实现了，读优先的话也是同样原理的，只是部分代码的执行顺序和部分条件判定不同而已

事与冀盼又落差，请不必惊怕