多线程开发之读写锁

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

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

#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也会等待写锁结束在打开。