读写锁和互斥量（互斥锁）很类似，是另一种线程同步机制，但不属于POSIX标准，可以用来同步同一进程中的各个线程。当然如果一个读写锁存放在多个进程共享的某个内存区中，那么还可以用来进行进程间的同步，
互斥量要么是锁住状态要么是不加锁状态，而且一次只有一个线程可以对其加锁。读写锁可以有三种状态：读模式下的加锁状态，写模式下的加锁状态，不加锁状态。
一次只有一个线程可以占有写模式的读写锁，但是多个线程可以同时占有读模式的读写锁。
- 当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁（读或写）的线程都会被阻塞。
- 当读写锁在读加锁状态时，所有试图以读模式对它加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须阻塞直到所有的线程释放读锁。
- 当读写锁在读加锁状态时，如果有另外的线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求。（后面有代码验证发现ubuntu 10.04系统下，不会阻塞随后的读模式的请求，最终导致请求写锁的线程饿死状态）这样可以避免读模式锁长期占有，而等待的写模式锁请求一直得不到满足，出现饿死情况。后面会测试ubuntu 10.04系统的情况。（注意前篇关于记录锁fcntl中，ubuntu 10.04系统下，进程拥有读锁，然后优先处理后面的读锁，再处理写锁，导致写锁出现饿死）
读写锁也称为共享-独占（shared-exclusive）锁，当读写锁以读模式加锁时，它是以共享模式锁住，当以写模式加锁时，它是以独占模式锁住。读写锁非常适合读数据的频率远大于写数据的频率从的应用中。这样可以在任何时刻运行多个读线程并发的执行，给程序带来了更高的并发度。
需要提到的是：读写锁到目前为止仍然不是属于POSIX标准。
1读写锁的初始化和销毁
#include <pthread.h>
int pthread_rwlock_init (pthread_rwlock_t *rwlock,const pthread_rwlockattr_t *attr);
int pthread_rwlock_destroy (pthread_rwlock_t *rwlock);
返回值：成功返回0，否则返回错误代码 与互斥量一样，读写锁在使用之前必须初始化，在释放它们底层的内存前必须销毁。上面两个函数分别由于读写锁的初始化和销毁。和互斥量，条件变量一样，如果读写锁是静态分配的，可以通过常量进行初始化，如下：
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;也可以通过pthread_rwlock_init()进行初始化。对于动态分配的读写锁由于不能直接赋值进行初始化，只能通过这种方式进行初始化。pthread_rwlock_init()第二个参数是读写锁的属性，如果采用默认属性，可以传入空指针NULL。
那么当不在需要使用时及释放（自动或者手动）读写锁占用的内存之前，需要调用pthread_rwlock_destroy()进行销毁读写锁占用的资源。
2读写锁的使用
/* 读模式下加锁 */
int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock);
/* 非阻塞的读模式下加锁 */
int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock);
/* 限时等待的读模式加锁 */
int pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock,const struct timespec *abstime);
/* 写模式下加锁 */
int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock);
/* 非阻塞的写模式下加锁 */
int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock);
/* 限时等待的写模式加锁 */
int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock,const struct timespec *abstime);
/* 解锁 */
int pthread_rwlock_unlock (pthread_rwlock_t *rwlock);
返回值：成功返回0，否则返回错误代码（1）pthread_rwlock_rdlock()系列函数pthread_rwlock_rdlock()用于以读模式即共享模式获取读写锁，如果读写锁已经被某个线程以写模式占用，那么调用线程就被阻塞。如果读写锁已经被某个线程以写模式占用，那么调用线程将获得读锁。如果读写锁未没有被占有，但有多个写锁正在等待该锁时，调用线程现在试图获取读锁，是否能获取该锁是不确定的。在实现读写锁的时候可以对共享模式下锁的数量进行限制（目前不知如何限制）。
pthread_rwlock_tryrdlock()和pthread_rwlock_rdlock()的唯一区别就是，在无法获取读写锁的时候，调用线程不会阻塞，会立即返回，并返回错误代码EBUSY。
针对未初始化的读写锁调用pthread_rwlock_rdlock/pthread_rwlock_tryrdlock，则结果是不确定的。
pthread_rwlock_timedrdlock()是限时等待读模式加锁，时间参数struct timespec * abstime也是绝对时间。
（2）pthread_rwlock_wrlock()系列函数
pthread_rwlock_wrlock()用于写模式即独占模式获取读写锁，如果读写锁已经被其他线程占用，不论是以共享模式还是独占模式占用，调用线程都会进入阻塞状态。
pthread_rwlock_trywrlock()在无法获取读写锁的时候，调用线程不会进入睡眠，会立即返回，并返回错误代码EBUSY。
针对未初始化的读写锁调用pthread_rwlock_wrlock/pthread_rwlock_trywrlock，则结果是不确定的。
pthread_rwlock_timedwrlock()是限时等待写模式加锁。
（3）pthread_rwlock_unlock()
无论以共享模式还是独占模式获得的读写锁，都可以通过调用pthread_rwlock_unlock()函数进行释放该读写锁。
针对未初始化的读写锁调用pthread_rwlock_unlock，则结果是不确定的。
注意：当读写锁以读模式被占有N次，即调用pthread_rwlock_rdlock() N次，且成功。则必须调用N次pthread_rwlock_unlock()才能执行匹配的解锁操作。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#define MAXDATA 1024
#define MAXREDER 100
#define MAXWRITER 100
struct
{
pthread_rwlock_t rwlock; //读写锁
char datas[MAXDATA]; //共享数据域
}shared = {
PTHREAD_RWLOCK_INITIALIZER
};
void *reader(void *arg);
void *writer(void *arg);
int main(int argc,char *argv[])
{
int i,readercount,writercount;
pthread_t tid_reader[MAXREDER],tid_writer[MAXWRITER];
if(argc != 3)
{
printf("usage : <reader_writer> #<readercount> #<writercount>
");
exit(0);
}
readercount = atoi(argv[1]); //读者个数
writercount = atoi(argv[2]); //写者个数
pthread_setconcurrency(readercount+writercount);
for(i=0;i<writercount;++i)
pthread_create(&tid_writer[i],NULL,writer,NULL);
sleep(1); //等待写者先执行
for(i=0;i<readercount;++i)
pthread_create(&tid_reader[i],NULL,reader,NULL);
//等待线程终止
for(i=0;i<writercount;++i)
pthread_join(tid_writer[i],NULL);
for(i=0;i<readercount;++i)
pthread_join(tid_reader[i],NULL);
exit(0);
}
void *reader(void *arg)
{
pthread_rwlock_rdlock(&shared.rwlock); //获取读出锁
if( pthread_rwlock_rdlock(&shared.rwlock) ==0 ) //获取读出锁
printf("pthread_rwlock_rdlock OK
");
printf("Reader begins read message.
");
printf("Read message is: %s
",shared.datas);
pthread_rwlock_unlock(&shared.rwlock); //释放锁
if( pthread_rwlock_unlock(&shared.rwlock) != 0 );
printf("pthread_rwlock_unlock fail
");
return NULL;
}
void *writer(void *arg)
{
char datas[MAXDATA];
pthread_rwlock_wrlock(&shared.rwlock); //获取写锁
if( pthread_rwlock_wrlock(&shared.rwlock) != 0)//再次获取写锁
perror("pthread_rwlock_wrlock");
if( pthread_rwlock_rdlock(&shared.rwlock) !=0 ) //获取读出锁
perror("pthread_rwlock_rdlock");
printf("Writers begings write message.
");
sleep(1);
printf("Enter the write message:
");
scanf("%s",datas); //写入数据
strcat(shared.datas,datas);
pthread_rwlock_unlock(&shared.rwlock); //释放锁
return NULL;
}运行结果：huangcheng@ubuntu:~$ gcc 2.c -lpthread huangcheng@ubuntu:~$ ./a.out 5 3 pthread_rwlock_wrlock: Success pthread_rwlock_rdlock: Success Writers begings write message. Enter the write message: hu pthread_rwlock_wrlock: Success pthread_rwlock_rdlock: Success Writers begings write message. Enter the write message: 1 pthread_rwlock_wrlock: Success pthread_rwlock_rdlock: Success Writers begings write message. Enter the write message: 2 pthread_rwlock_rdlock OK Reader begins read message. Read message is: hu12 pthread_rwlock_unlock fail pthread_rwlock_rdlock OK Reader begins read message. Read message is: hu12 pthread_rwlock_unlock fail pthread_rwlock_rdlock OK Reader begins read message. Read message is: hu12 pthread_rwlock_unlock fail pthread_rwlock_rdlock OK Reader begins read message. Read message is: hu12 pthread_rwlock_unlock fail pthread_rwlock_rdlock OK Reader begins read message. Read message is: hu12 pthread_rwlock_unlock fail
结果说明：（1）当一个线程获得读写锁的写模式，其他线程试图获得该读写锁的读模式或者是写模式，都将会阻塞，直到该线程释放该读写锁。
（2）当一个线程获得读写锁的写模式，该线程试图获得该读写锁的读模式或写模式，都会立即返回失败，不会导致失败。
（3）当一个线程获得读写锁的读模式，如果该线程试图获得该读写锁的读模式，则返回成功，并在该线程释放该读写锁只需要释放一次，第二次会释放失败。
（4）当一个线程获得读写锁的读模式，且还没有释放该读写锁，如果该线程试图获得该读写锁的写模式，将导致阻塞，直到该线程释放该读写锁。
（5）当一个线程获得读写锁的写模式，该线程试图释放该写锁两次，将导致不可预测的问题。
（6）当一个线程获得读写锁的写模式或者读模式，不能读该读写锁释放两次。即不管该线程获得读锁几次，都只需要释放该读写锁一次就OK。
3读写锁的属性设置
/* 初始化读写锁属性对象 */
int pthread_rwlockattr_init (pthread_rwlockattr_t *attr);
/* 销毁读写锁属性对象 */
int pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr);
/* 获取读写锁属性对象在进程间共享与否的标识*/
int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *attr,int *pshared);
/* 设置读写锁属性对象，标识在进程间共享与否 */
int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared);
返回值：成功返回0，否则返回错误代码pthread_rwlockattr_setpshared()函数的第二个参数pshared用于设定是否进程间共享，其值可以是PTHREAD_PROCESS_PRIVATE或PTHREAD_PROCESS_SHARED，后者是设置进程间共享。
示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
struct{
pthread_rwlock_t rwlock;
int product;
}sharedData = {PTHREAD_RWLOCK_INITIALIZER, 0};
void * produce(void *ptr)
{
int i;
for ( i = 0; i < 5; ++i)
{
pthread_rwlock_wrlock(&sharedData.rwlock);
sharedData.product = i;
printf("produce:%d
",i);
pthread_rwlock_unlock(&sharedData.rwlock);
sleep(1);
}
}
void * consume1(void *ptr)
{
int i;
for ( i = 0; i < 5;)
{
pthread_rwlock_rdlock(&sharedData.rwlock);
printf("consume1:%d
",sharedData.product);
pthread_rwlock_unlock(&sharedData.rwlock);
++i;
sleep(1);
}
}
void * consume2(void *ptr)
{
int i;
for ( i = 0; i < 5;)
{
pthread_rwlock_rdlock(&sharedData.rwlock);
printf("consume2:%d
",sharedData.product);
pthread_rwlock_unlock(&sharedData.rwlock);
++i;
sleep(1);
}
}
int main()
{
pthread_t tid1, tid2, tid3;
pthread_create(&tid1, NULL, produce, NULL);
pthread_create(&tid2, NULL, consume1, NULL);
pthread_create(&tid3, NULL, consume2, NULL);
void *retVal;
pthread_join(tid1, &retVal);
pthread_join(tid2, &retVal);
pthread_join(tid3, &retVal);
return 0;
}运行结果：huangcheng@ubuntu:~$ ./a.out consume2:0 consume1:0 produce:0 consume2:0 consume1:0 produce:1 consume2:1 consume1:1 produce:2 consume2:2 consume1:2 produce:3 consume2:3 consume1:3 produce:4 huangcheng@ubuntu:~$
如果把consume1的解锁注释掉，如下：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
struct{
pthread_rwlock_t rwlock;
int product;
}sharedData = {PTHREAD_RWLOCK_INITIALIZER, 0};
void * produce(void *ptr)
{
int i;
for ( i = 0; i < 5; ++i)
{
pthread_rwlock_wrlock(&sharedData.rwlock);
sharedData.product = i;
printf("produce:%d
",i);
pthread_rwlock_unlock(&sharedData.rwlock);
sleep(1);
}
}
void * consume1(void *ptr)
{
int i;
for ( i = 0; i < 5;)
{
pthread_rwlock_rdlock(&sharedData.rwlock);
printf("consume1:%d
",sharedData.product);
// pthread_rwlock_unlock(&sharedData.rwlock);
++i;
sleep(1);
}
}
void * consume2(void *ptr)
{
int i;
for ( i = 0; i < 5;)
{
pthread_rwlock_rdlock(&sharedData.rwlock);
printf("consume2:%d
",sharedData.product);
pthread_rwlock_unlock(&sharedData.rwlock);
++i;
sleep(1);
}
}
int main()
{
pthread_t tid1, tid2, tid3;
pthread_create(&tid1, NULL, produce, NULL);
pthread_create(&tid2, NULL, consume1, NULL);
pthread_create(&tid3, NULL, consume2, NULL);
void *retVal;
pthread_join(tid1, &retVal);
pthread_join(tid2, &retVal);
pthread_join(tid3, &retVal);
return 0;
}程序运行结果：huangcheng@ubuntu:~$ ./a.out consume2:0 consume1:0 consume2:0 consume1:0 consume2:0 consume1:0 consume2:0 consume1:0 consume2:0 consume1:0 最后程序保持阻塞状态从执行结果可以看出Ubuntu 10.04提供的读写锁函数是优先考虑等待读模式占用锁的线程，这种实现的一个很大缺陷就是出现写入线程饿死的情况。