Linux下读写锁的编写及相关问题

读写锁和互斥量类似，不过读写锁允许更高的并行性。互斥量要么是锁住状态，要么就是不加做状态，而且一次只有一个线程可以对其加锁。

读写锁的三种状态：

1. 读模式下加锁状态
2. 写模式下加锁状态
3. 不加锁状态

一次只有一个线程可以占有写模式的读写锁，但是可以多个线程同时占有读模式的读写锁

即同时可以有n个读，但是只能由一个写

• 读写锁也叫共享互斥锁
• 当读写锁是读模式锁住时，就可以说成是以共享模式锁住的。
• 当他是写模式下锁住的时候，就可以说成是以互斥模式锁住的。

定义

定义及销毁

#include<pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destory(pthread_rwlock_t *rwlock);

若成功返回0，否则，返回错误编码

加锁解锁

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

读模式下锁调用第一个函数，写模式下调用第二个函数。

不论是那种方式锁住，都可以调用第三个函数进行解锁

例子：

即可以同时又n个读状态的结果，但是一个时间只能有一个写的状态

#include<iostream>
#include<unistd.h>
#include<stdlib.h>
#include<pthread.h>

using namespace std;
pthread_rwlock_t rwlock;

void *readthread(void *arg)
{
        while(1){
                pthread_rwlock_rdlock(&rwlock);
                cout<<"read"<<endl;
                pthread_rwlock_unlock(&rwlock);
                sleep(3);
        }
}

void *writethread(void *arg)
{
        while(1){
                pthread_rwlock_wrlock(&rwlock);
                cout<<"write"<<endl;
                pthread_rwlock_unlock(&rwlock);
                sleep(3);
        }
}

int main()
{
        pthread_t ptd[10];
        int i,err;
        pthread_rwlock_init(&rwlock,NULL);
        for(i=0;i<7;i++)
        {
                err=pthread_create(&ptd[i],NULL,readthread,NULL);
                if(err!=0)
                {
                        cout<<"readcreate error"<<endl;
                }
        }
        for(i=7;i<10;i++)
        {
                err=pthread_create(&ptd[i],NULL,writethread,NULL);
                if(err!=0)
                {
                        cout<<"writecreate error"<<endl;
                }
        }

        for(int i=0;i<7;i++)
        {
                pthread_join(ptd[i],NULL);
        }
        pthread_rwlock_destroy(&rwlock);
}