多线程开发之读写锁

读写锁与互斥量类似，不过读写锁允许更高的并行，互斥量要么是锁住状态，要么是不加锁状态。而且一次只有一个线程可以对其枷锁。读写锁就不一样了，虽然一次只有一个线程可以占有写模式的读写锁，但是多个可以同时占有读模式的读写锁。

首先介绍：读锁，具体看代码：

#include <iostream>
#include<pthread.h>
#include<unistd.h>
using namespace std;
int glable_num=10;
pthread_rwlock_t lock;
void *read_fn(void *arg)
{
    char *name=(char*)arg;

    for(int i=0;i<5;i++)
    {
        pthread_rwlock_rdlock(&lock);
        cout<<"come in:"<<glable_num<<":"<<name<<endl;
        sleep(1);
        cout<<"leave:"<<name<<endl;

        pthread_rwlock_unlock(&lock);
        sleep(1);
    }

    return ((void *)0);
}
void *write_fn(void *arg)
{
    char *name=(char*)arg;

    for(int i=0;i<5;i++)
    {
        pthread_rwlock_wrlock(&lock);
        glable_num++;
        cout<<"come in:"<<glable_num<<":"<<name<<endl;
        sleep(1);
        cout<<"leave:"<<name<<endl;

        pthread_rwlock_unlock(&lock);
        sleep(1);
    }

    return ((void *)0);
}
int main()
{

    pthread_t read_1,read_2,write_1,write_2;
    char *read1="read_1";
    char *read2="read_2";
    char *write1="write_1";
    pthread_rwlock_init(&lock,NULL);
    pthread_create(&read_1,NULL,read_fn,(void*)read1);
    pthread_create(&read_2,NULL,read_fn,(void*)read2);

    pthread_join(read_1,NULL);
    pthread_join(read_2,NULL);
 
    pthread_rwlock_destroy(&lock);

    return 0;

}

从以上结果可以看出来，当有一个读锁加了之后，在加读锁是可以的。并不会阻塞，而是读锁1打开之后，读锁2打开，最后再是读锁1关闭，读锁2关闭。

写锁：具体看代码

#include <iostream>
#include<pthread.h>
#include<unistd.h>
using namespace std;
int glable_num=10;
pthread_rwlock_t lock;
void *read_fn(void *arg)
{
    char *name=(char*)arg;

    for(int i=0;i<5;i++)
    {
        pthread_rwlock_rdlock(&lock);
        cout<<"come in:"<<glable_num<<":"<<name<<endl;
        sleep(1);
        cout<<"leave:"<<name<<endl;

        pthread_rwlock_unlock(&lock);
        sleep(1);
    }

    return ((void *)0);
}
void *write_fn(void *arg)
{
    char *name=(char*)arg;

    for(int i=0;i<5;i++)
    {
        pthread_rwlock_wrlock(&lock);
        glable_num++;
        cout<<"come in:"<<glable_num<<":"<<name<<endl;
        sleep(1);
        cout<<"leave:"<<name<<endl;

        pthread_rwlock_unlock(&lock);
        sleep(1);
    }

    return ((void *)0);
}
int main()
{

    pthread_t read_1,read_2,write_1,write_2;
    char *read1="read_1";
    char *read2="read_2";
    char *write1="write_1";
    pthread_rwlock_init(&lock,NULL);
    pthread_create(&read_1,NULL,read_fn,(void*)read1);
    pthread_create(&write_1,NULL,write_fn,(void*)write1);
    pthread_create(&read_2,NULL,read_fn,(void*)read2);

    pthread_join(read_1,NULL);
    pthread_join(read_2,NULL);
    pthread_join(write_1,NULL);
    pthread_rwlock_destroy(&lock);

    return 0;
}

通过结果可以看出，打开读锁1的时候，想打开写锁1只有等到读锁1结束了，写锁才会打开，然而在写锁1之后打开读锁2的时候，读锁2也会等待写锁结束在打开。