位置：广州松河 > 技术支持 > Linux读写锁详解

Linux读写锁详解

来源：网络整理时间：2023/2/17 14:37:04 共 3635 浏览

多线程程序中，如果仅有少数线程会对共享数据进行修改，多数线程只是读取共享数据的值，就适合用读写锁解决“线程间抢夺资源”的问题。

读写锁的核心思想是：将线程访问共享数据时发出的请求分为两种，分别是：

读请求：只读取共享数据，不做任何修改；
写请求：存在修改共享数据的行为。

当有多个线程发出读请求时，这些线程可以同时执行，也就是说，共享数据的值可以同时被多个发出读请求的线程获取；当有多个线程发出写请求时，这些线程只能一个一个地执行（同步执行）。此外，当发出读请求的线程正在执行时，发出写请求的线程必须等待前者执行完后才能开始执行；当发出写请求的线程正在执行时，发出读请求的线程也必须等待前者执行完后才能开始执行。

本质上，读写锁就是一个全局变量，发出读请求和写请求的线程都可以访问它。为了区别线程发出的请求类别，当读写锁被发出读请求的线程占用时，我们称它为“读锁”；当读写锁被发出写请求的线程占用时，称它为“写锁”。

为了让您更清楚地了解读写锁在多线程程序中发挥的作用，我们制作了下面这张表格：

表 1 读写锁的作用
当前读写锁的状态	线程发出“读”请求	线程发出“写”请求
无锁	允许占用	允许占用
读锁	允许占用	阻塞线程执行
写锁	阻塞线程执行	阻塞线程执行

从上表可以看出，不同状态下的读写锁会以不同的方式处理发出读请求或写请求的线程：
1) 当读写锁未被任何线程占用时，发出读请求和写请求的线程都可以占用它。注意，由于读请求和写请求的线程不能同时执行，读写锁默认会优先分配给发出读请求的线程。

2) 当读写锁的状态为“读锁”时，表明当前执行的是发出读请求的线程（可能有多个）。此时如果又有线程发出读请求，该线程不会被阻塞，但如果有线程发出写请求，它就会被阻塞，直到读写锁状态改为“无锁”。

3) 当读写锁状态为“写锁”时，表明当前执行的是发出写请求的线程（只能有 1 个）。此时无论其它线程发出的是读请求还是写请求，都必须等待读写锁状态改为“无锁”后才能执行。

总的来说，对于进程空间中的共享资源，读写锁允许发出“读”请求的线程共享资源，发出“写”请求的线程必须独占资源，进而实现线程同步。

读写锁的具体用法

POSIX 标准中，读写锁用 pthread_rwlock_t 类型的变量表示，此类型定义在<pthread.h>头文件中。举个例子：

pthread_rwlock_t myRWLock;

由此，我们就成功创建了一个读写锁。但要想使用 myRWLock 读写锁，还需要进行初始化操作。

1) 初始化读写锁

初始化读写锁的方法有两种，一种是直接将 PTHREAD_RWLOCK_INITIALIZER 宏赋值给读写锁变量，例如：

pthread_rwlock_t myRWLock = PTHREAD_RWLOCK_INITIALIZER;

还可以借助 pthread_rwlock_init() 函数初始化读写锁，此函数的语法格式为：

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

rwlock 参数用于指定要初始化的读写锁变量；attr 参数用于自定义读写锁变量的属性，置为 NULL 时表示以默认属性初始化读写锁。

当 pthread_rwlock_init() 函数初始化成功时，返回数字 0，反之返回非零数。

当 attr 参数为 NULL 时，以上两种初始化方式完全等价。

2) 线程发出“读锁”请求

通过以下两个函数，线程可以向读写锁发出“读锁”请求：

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);

其中，rwlock 参数指的是初始化好的读写锁。

当读写锁处于“无锁”或者“读锁”状态时，以上两个函数都能成功获得读锁；当读写锁处于“写锁”状态时：

pthread_rwlock_rdlock() 函数会阻塞当前线程，直至读写锁被释放；
pthread_rwlock_tryrdlock() 函数不会阻塞当前线程，直接返回 EBUSY。

以上两个函数如果能成功获得读锁，函数返回数字 0，反之返回非零数。

3) 线程发出“写锁”请求

通过以下两个函数，线程可以向读写锁发出“写锁”请求：

int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);

rwlock 参数指的是初始化好的读写锁。

当读写锁处于“无锁”状态时，两个函数都能成功获得写锁；当读写锁处于“读锁”或“写锁”状态时：

pthread_rwlock_wrlock() 函数将阻塞线程，直至读写锁被释放；
pthread_rwlock_trywrlock() 函数不会阻塞线程，直接返回 EBUSY。

以上两个函数如果能成功获得写锁，函数返回数字 0，反之返回非零数。

4) 释放读写锁

无论是处于“无锁”、“读锁”还是“写锁”的读写锁，都可以使用如下函数释放读写锁：

int pthread_rwlock_unlock (pthread_rwlock_t* rwlock);

rwlock 参数表示要释放的读写锁。

当函数成功释放读写锁时，返回数字 0，反之则返回非零数。注意，由于多个线程可以同时获得“读锁”状态下的读写锁，这种情况下一个线程释放读写锁后，读写锁仍处于“读锁”状态，直至所有线程都释放读写锁，读写锁的状态才为“无锁”状态。

5) 销毁读写锁

当读写锁不再使用时，我们可以借助如下函数将它销毁：

int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);

参数 rwlock 表示要销毁的目标读写锁。

如果函数成功销毁指定的读写锁，返回数字 0，反之则返回非零数。

读写锁的实际应用

接下来通过一个实例，给您演示读写锁的用法：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
int x = 0;
//创建读写锁变量
pthread_rwlock_t myrwlock;

void* read_thread(void* args){
    printf("------%u read_thread ready\n",pthread_self());
    while (1)
    {
        sleep(1);
        //请求读锁
        pthread_rwlock_rdlock(&myrwlock);
        printf("read_thread: %u,x=%d\n", pthread_self(), x);
        sleep(1);
        //释放读写锁
        pthread_rwlock_unlock(&myrwlock);
    }
    return NULL;
}

void* write_thread(void* param)
{
    printf("------%u write_thread ready!\n",pthread_self());
    while (1)
    {
        sleep(1);
        // 请求写锁
        pthread_rwlock_wrlock(&myrwlock);
        ++x;
        printf("write_thread: %u,x=%d\n", pthread_self(), x);
        sleep(1);
        //释放读写锁
        pthread_rwlock_unlock(&myrwlock);
    }
    return NULL;
}

int main()
{
    int i;
    //初始化读写锁
    pthread_rwlock_init(&myrwlock, NULL);
    //创建 3 个读 x 变量的线程
    pthread_t readThread[3];
    for (i = 0; i < 3; ++i)
    {
        pthread_create(&readThread[i], NULL, read_thread, NULL);
    }
    //创建 1 个修改 x 变量的线程
    pthread_t writeThread;
    pthread_create(&writeThread, NULL, write_thread, NULL);
    //等待各个线程执行完成
    pthread_join(writeThread, NULL);

    for (int i = 0; i < 3; ++i)
    {
        pthread_join(readThread[i], NULL);
    }
    //销毁读写锁
    pthread_rwlock_destroy(&myrwlock);
    return 0;
}

假设程序编写在 thread.c 文件中，执行过程如下：

[root@localhost ~]# gcc thread.c -o thread.exe -lpthread
[root@localhost ~]# ./mythread.exe
------1134741248 read_thread ready
------1113761536 read_thread ready
------1103271680 write_thread ready!
------1124251392 read_thread ready
read_thread: 1124251392,x=0
read_thread: 1113761536,x=0
read_thread: 1134741248,x=0
write_thread: 1103271680,x=1
read_thread: 1134741248,x=1
read_thread: 1124251392,x=1
read_thread: 1113761536,x=1
write_thread: 1103271680,x=2
read_thread: 1124251392,x=2
read_thread: 1113761536,x=2
read_thread: 1134741248,x=2

注意，此程序会一直执行，按 "Ctrl+Z" 组合键可以使程序停止。

程序中共创建了 4 个子线程，其中 3 个线程用于读取 x 变量的值，读取变量前会先获得“读锁”。剩余的 1 个线程用于修改 x 变量的值，修改前先获得“写锁”。

通过执行结果不难看到，3 个读取 x 变量的线程总是能够同时获取到 x 变量的值，因为它们能够同时获得“读锁”并同时执行。

除了读写锁，线程同步的实现方式还有互斥锁、信号量以及条件变量。

版权说明：
本网站凡注明“广州松河原创”的皆为本站原创文章，如需转载请注明出处！
本网转载皆注明出处，遵循行业规范，如发现作品内容版权或其它问题的，请与我们联系处理！
欢迎扫描右侧微信二维码与我们联系。

·上一条：Linux线程死锁详解 | ·下一条：Linux条件变量详解