Linux系统编程-线程（二）-线程同步03：读写锁

雨点打透心脏的1/2处 2023-09-27 11:18 74阅读 0赞

## 一、读写锁概述 ##

当有一个线程已经持有互斥锁时，互斥锁将所有试图进入临界区的线程都阻塞住。但是考虑一种情形，当前持有互斥锁的线程只是要读访问共享资源，而同时有其它几个线程也想读取这个共享资源，但是由于互斥锁的排它性，所有其它线程都无法获取锁，也就无法读访问共享资源了，但是实际上多个线程同时读访问共享资源并不会导致问题。

在对数据的读写操作中，更多的是读操作，写操作较少，例如对数据库数据的读写应用。为了满足当前能够允许多个读出，但只允许一个写入的需求，线程提供了**读写锁**来实现。

读写锁的特点如下：

1）如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作。

2）如果有其它线程写数据，则其它线程都不允许读、写操作。

读写锁分为读锁和写锁，规则如下：

1）如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁。

2）如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。

POSIX 定义的读写锁的数据类型是： pthread\_rwlock\_t。

## 二、读写锁相关函数 ##

### 1、pthread\_rwlock\_init函数 ###

#include <pthread.h>
    
    int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
        const pthread_rwlockattr_t *restrict attr);
    功能：
        用来初始化 rwlock 所指向的读写锁。
    
    参数：
        rwlock：指向要初始化的读写锁指针。
        attr：读写锁的属性指针。如果 attr 为 NULL 则会使用默认的属性初始化读写锁，否则使用指定的 attr 初始化读写锁。
    
        可以使用宏 PTHREAD_RWLOCK_INITIALIZER 静态初始化读写锁，比如：
        pthread_rwlock_t my_rwlock = PTHREAD_RWLOCK_INITIALIZER;
    
        这种方法等价于使用 NULL 指定的 attr 参数调用 pthread_rwlock_init() 来完成动态初始化，不同之处在于PTHREAD_RWLOCK_INITIALIZER 宏不进行错误检查。
    
    返回值：
        成功：0，读写锁的状态将成为已初始化和已解锁。
        失败：非 0 错误码。

### 2、pthread\_rwlock\_destroy函数 ###

#include <pthread.h>
    
    int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
    功能：
        用于销毁一个读写锁，并释放所有相关联的资源（所谓的所有指的是由 pthread_rwlock_init() 自动申请的资源） 。
    参数：
        rwlock：读写锁指针。
    返回值：
        成功：0
        失败：非 0 错误码

### 3、pthread\_rwlock\_rdlock函数 ###

#include <pthread.h>
    
    int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
    功能：
        以阻塞方式在读写锁上获取读锁（读锁定）。
        如果没有写者持有该锁，并且没有写者阻塞在该锁上，则调用线程会获取读锁。
        如果调用线程未获取读锁，则它将阻塞直到它获取了该锁。一个线程可以在一个读写锁上多次执行读锁定。
        线程可以成功调用 pthread_rwlock_rdlock() 函数 n 次，但是之后该线程必须调用 pthread_rwlock_unlock() 函数 n 次才能解除锁定。
    参数：
        rwlock：读写锁指针。
    返回值：
        成功：0
        失败：非 0 错误码
    
    int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
       用于尝试以非阻塞的方式来在读写锁上获取读锁。
       如果有任何的写者持有该锁或有写者阻塞在该读写锁上，则立即失败返回。

### 4、pthread\_rwlock\_wrlock函数 ###

#include <pthread.h>
    
    int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
    功能：
        在读写锁上获取写锁（写锁定）。
        如果没有写者持有该锁，并且没有写者读者持有该锁，则调用线程会获取写锁。
        如果调用线程未获取写锁，则它将阻塞直到它获取了该锁。
    参数：
        rwlock：读写锁指针。
    返回值：
        成功：0
        失败：非 0 错误码
    
    int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
       用于尝试以非阻塞的方式来在读写锁上获取写锁。
       如果有任何的读者或写者持有该锁，则立即失败返回。

### 5、pthread\_rwlock\_unlock函数 ###

#include <pthread.h>
    
    int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
    功能：
        无论是读锁或写锁，都可以通过此函数解锁。
    参数：
        rwlock：读写锁指针。
    返回值：
        成功：0
        失败：非 0 错误码

## 三、测试程序示例 ##

下面是一个使用读写锁来实现 4 个线程读写一段数据是实例。

在此示例程序中，共创建了 4 个线程，其中两个线程用来写入数据，两个线程用来读取数据。当某个线程读操作时，其他线程允许读操作，却不允许写操作；当某个线程写操作时，其它线程都不允许读或写操作。

pthread_rwlock_t rwlock; //读写锁
    int num = 1;
    
    //读操作，其他线程允许读操作，却不允许写操作
    void *fun1(void *arg)
    {
        while (1)
        {
            pthread_rwlock_rdlock(&rwlock);
            printf("read num first===%d\n", num);
            pthread_rwlock_unlock(&rwlock);
            sleep(1);
        }
    }
    
    //读操作，其他线程允许读操作，却不允许写操作
    void *fun2(void *arg)
    {
        while (1)
        {
            pthread_rwlock_rdlock(&rwlock);
            printf("read num second===%d\n", num);
            pthread_rwlock_unlock(&rwlock);
            sleep(2);
        }
    }
    
    //写操作，其它线程都不允许读或写操作
    void *fun3(void *arg)
    {
        while (1)
        {
    
            pthread_rwlock_wrlock(&rwlock);
            num++;
            printf("write thread first\n");
            pthread_rwlock_unlock(&rwlock);
            sleep(2);
        }
    }
    
    //写操作，其它线程都不允许读或写操作
    void *fun4(void *arg)
    {
        while (1)
        {
    
            pthread_rwlock_wrlock(&rwlock);
            num++;
            printf("write thread second\n");
            pthread_rwlock_unlock(&rwlock);
            sleep(1);
        }
    }
    
    int main()
    {
        pthread_t ptd1, ptd2, ptd3, ptd4;
    
        pthread_rwlock_init(&rwlock, NULL);//初始化一个读写锁
    
        //创建线程
        pthread_create(&ptd1, NULL, fun1, NULL);
        pthread_create(&ptd2, NULL, fun2, NULL);
        pthread_create(&ptd3, NULL, fun3, NULL);
        pthread_create(&ptd4, NULL, fun4, NULL);
    
        //等待线程结束，回收其资源
        pthread_join(ptd1, NULL);
        pthread_join(ptd2, NULL);
        pthread_join(ptd3, NULL);
        pthread_join(ptd4, NULL);
    
        pthread_rwlock_destroy(&rwlock);//销毁读写锁
    
        return 0;
    }