Linux线程同步机制三--读写锁rwlock

一、读写锁基本原理

　　在对数据的读写应用中，很多情况是大量的读操作，而写操作较少，例如对数据库数据的访问。显然使用互斥锁将极大地影响效率。为满足这一应用领域，posix线程提供了读写锁机制，骑基本原则如下：
　　1.如果当前线程读数据，则允许其他线程执行读操作，但不允许写操作；
　　2.如果当前线程写数据，则其他线程的读、写操作均不允许。
　　
　　因此，读写锁分为了读锁和写锁。具体如下所示：
　　1.如果某线程申请了读锁，其他线程可以再申请读锁，但不能申请写锁；
　　2.如果某线程申请了写锁，则其他线程不能申请读锁，也不能申请写锁。

二、读写锁基本操作函数

　　读写锁基本操作函数如下表所示：
　

1.初始化读写锁
　　在使用读写锁前，需要定义读写斥锁（全局变量），定义读写锁的代码入下：

pthread_rwlock_t rwlock;

　　pthread_rwlock_init()函数用于初始化读写锁，其函数声明为：

int pthread_rwlock_init(pthread_rwlock_t* rwlock, pthread_rwlockattr_t* attr);

　　第1个参数rwlock是指向要初始化的读写锁的指针；
　　第2个参数attr指向属性对象的指针，该属性定义要初始化的读写锁的特性，此参数设置为NULL时，则使用默认属性。
　　
　　函数执行成功是返回0，否则返回一个错误编号，以指明错误。

　　下面是一段初始化读写锁的代码：

pthread_rwlock_t rwlock;
pthread_rwlockattr_tcattr;
int ret;
ret = pthread_rwlock_init(&cv, NULL);      // 使用默认属性初始化读写锁
ret = pthread_rwlock_init(&cv, &cattr);    // 使用自定义属性初始化读写锁

　　也可以使用宏PTHREAD_RWLOCK_INITIALIZER初始化静态分配的读写锁。这相当于调用pthread_rwlock_init()动态初始化时指定attr参数为NULL。区别在于，它不执行错误检查。下面是使用此宏初始化读写锁代码：

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

2.申请读锁
　　pthread_rwlock_rdlock()函数以阻塞的方式来申请读锁，其函数声明如下：

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);

　　pthread_rwlock_tryrdlock()函数以阻塞的方式来申请读锁，其函数声明如下：

int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);

　　如果不能申请到锁，pthread_rwlock_rdlock()将阻塞当前线程，而pthread_rwlock_tryrdlock()将返回错误。

　　两函数执行成功时返回0。否则，返回错误编号以指明错误。

3.申请写锁
　　pthread_rwlock_wrlock()函数以阻塞的方式来申请读锁，其函数声明如下：

int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);

　　pthread_rwlock_trywrlock()函数以阻塞的方式来申请读锁，其函数声明如下：

int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);

　　如果不能申请到锁，pthread_rwlock_wrlock()将阻塞当前线程，而pthread_rwlock_trywrlock()将返回错误。

　　两函数执行成功时返回0。否则，返回错误编号以指明错误（未设置errno变量）。

4.解锁
　　无弄是读锁还是写锁都将使用函数pthread_rwlock_unlock()来释放锁，此函数声明如下：

int pthread_rwlock_unlock(pthread_rwlock_t* rwlock);

　　使用此函数需要注意一下情况：
　　1.如果调用此函数来释放读锁，但当前还有其他读锁定，则保持读锁定状态，只不过当前线程已不再是其所有者之一。只有当最后一个读锁释放，则读写锁将处于解锁状态。
　　2.如果调用此函数释放写锁，则置读写锁为解锁状态。
　　
　　此函数执行成功时返回0。否则，返回错误编号以指明错误。

5.销毁读写锁
　　pthread_rwlock_destroy()函数用来销毁读写锁，其函数申明如下:

int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);

　　参数rwlock指向要销毁的读写锁的指针。
　　
　　函数执行成功时返回0。否则，返回错误编码号以指明错误。

三、示例

　　下面通过4个线程对一个全局变量的操作来展示，其中2个线程是读操作，2个线程是写操作，代码如下所示：

#include <stdio.h>  
#include <pthread.h>

int num = 0;

pthread_rwlock_t rwlock;

void* pth_read(void* arg)
{
    char* name = (char*)arg;

    while (num < 3) {
        printf("Read thread %s get read lock\n", name);
        pthread_rwlock_rdlock(&rwlock);

        printf("Read thread %s read data:%d\n", name, num);

        sleep(1);   // 模拟读数据时间为1S

        printf("Read thread %s release read lock\n", name);
        pthread_rwlock_unlock(&rwlock);

        sleep(2);   // 每隔2S读一次数据
    }

    pthread_exit(0);
}

void* pth_write(void* arg)
{
    char* name = (char*)arg;

    while (num < 3) {
        printf("Write thread %s get write lock\n", name);
        pthread_rwlock_wrlock(&rwlock);

        num ++;
        printf("Write thread %s write data:%d\n", name, num);

        sleep(2);   // 模拟写数据需要2S

        printf("Write thread %s release write lock\n", name);
        pthread_rwlock_unlock(&rwlock);

        sleep(1);   // 每隔1S写一次数据
    }

    pthread_exit(0);
}

int main()  
{  
    pthread_t tid1, tid2, tid3, tid4;
    int ret;

    // 初始化锁
    pthread_rwlock_init(&rwlock, NULL);

    ret = pthread_create(&tid1, NULL, pth_read, "A");
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid2, NULL, pth_read, "B");
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid3, NULL, pth_write, "C");
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

    ret = pthread_create(&tid4, NULL, pth_write, "D");
    if (0 != ret) {
        perror("create pthead error");
        return -1;
    }

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

    // 销毁锁
    pthread_rwlock_destroy(&rwlock);

    return 0;
}

运行结果如下图所示：

　　由上图可知，在别的线程（A线程）持有读锁的时候，其他线程（B线程）还可以获取到读锁。但只有当所有的读锁释放后写锁才能持有。同样只有当写锁释放时，读锁才能获取到锁。