【在Linux世界中追寻伟大的One Piece】读者写者问题与读写锁

1 -> 读者写者问题

1.1 -> 什么是读者写者问题

• 多个读者可以同时访问共享资源。例如，在一个数据库系统中，多个用户(读者)可以同时读取数据库中的某些数据，只要没有写操作在进行，这种并发读取不会导致数据的不一致性。
• 写者在对共享资源进行写操作时，必须独占资源。因为如果有多个写者同时写或者有读者在同时读取时写者进行写操作，都可能导致数据的不一致性。比如在文件系统中，一个进程(写者)在修改文件内容时，如果其他进程(读者或写者)同时操作这个文件，文件内容就可能变得混乱。
• 设计一种并发控制机制，既能保证多个读者的并发访问，又能确保写者对共享资源的独占访问，并且在写者等待访问资源时，新到达的读者不会无限期地抢占写者的访问权，以避免写者“饥饿”现象。这通常需要使用信号量等同步原语来实现。

1.2 -> 读者写者与生产消费者的区别

对比维度读者写者模型生产消费者模型数据访问读者只读，写者只写生产者生产，消费者消费并发访问读者并行，写者互斥生产者和消费者互斥使用场景多读少写大量短时任务数据处理无消费者处理数据同步机制读写锁****互斥锁或信号量
通过对比可以看出，读者写者模型更适合于数据的并发读取，而生产消费者模型更适合于数据的生产和消费。在实际应用中，应根据具体的业务需求选择合适的模型。

1.3 -> 如何理解读者写者问题

伪代码如下：

• 公共部分：

uint32_t reader_count = 0;
lock_t count_lock;
lock_t writer_lock;

• Reader

// 加锁
lock(count_lock);
if (reader_count == 0)
    lock(writer_lock);
++reader_count;
unlock(count_lock);

// read;
//解锁
lock(count_lock);
--reader_count;
if (reader_count == 0)
    unlock(writer_lock);
unlock(count_lock);

• Writer

lock(writer_lock);

// write
unlock(writer_lock);

2 -> 读写锁

在编写多线程的时候，有一种情况是十分常见的。那就是，有些公共数据修改的机会比较少。相比较改写，它们读的机会反而高的多。通常而言，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极大地降低我们程序的效率。那么有没有一种方法，可以专门处理这种多读少写的情况呢？有，那就是读写锁。
当前锁状态读锁请求写锁请求无锁可以可以读锁可以阻塞写锁阻塞****阻塞
注意：写独占，读共享，读锁优先级高。

2.1 -> 读写锁接口

设置读写优先

int pthread_rwlockattr_setkind_np(pthread_rwlockattr_t* attr, int pref);
/*
pref 共有 3 种选择
PTHREAD_RWLOCK_PREFER_READER_NP (默认设置) 读者优先，可能会导致写者饥饿情况
PTHREAD_RWLOCK_PREFER_WRITER_NP 写者优先，目前有 BUG，导致表现行为和PTHREAD_RWLOCK_PREFER_READER_NP 一致
PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP 写者优先，但写者不能递归加锁
*/

初始化

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

销毁

int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);

加锁和解锁

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t* rwlock);

读写锁案例

#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <vector>
#include <cstdlib>
#include <ctime>

// 共享资源
int shared_data = 0;

// 读写锁
pthread_rwlock_t rwlock;

// 读者线程函数
void* Reader(void* arg)
{
    //sleep(1); //读者优先，一旦读者进入&&读者很多，写者基本就很难进入了
    int number = *(int*)arg;
    while (true)
    {
        pthread_rwlock_rdlock(&rwlock); // 读者加锁
        std::cout << "读者-" << number << " 正在读取数据, 数据是: "
            << shared_data << std::endl;
        sleep(1); // 模拟读取操作
        pthread_rwlock_unlock(&rwlock); // 解锁
    }

    delete (int*)arg;
    return NULL;
}

// 写者线程函数
void* Writer(void* arg)
{
    int number = *(int*)arg;
    while (true)
    {
        pthread_rwlock_wrlock(&rwlock); // 写者加锁
        shared_data = rand() % 100; // 修改共享数据
        std::cout << "写者- " << number << " 正在写入. 新的数据是: "
            << shared_data << std::endl;
        sleep(2); // 模拟写入操作
        pthread_rwlock_unlock(&rwlock); // 解锁
    }

    delete (int*)arg;
    return NULL;
}

int main()
{
    srand(time(nullptr) ^ getpid());
    pthread_rwlock_init(&rwlock, NULL); // 初始化读写锁

    // 可以更高读写数量配比，观察现象
    const int reader_num = 2;
    const int writer_num = 2;
    const int total = reader_num + writer_num;
    pthread_t threads[total]; // 假设读者和写者数量相等

    // 创建读者线程
    for (int i = 0; i < reader_num; ++i)
    {
        int* id = new int(i);
        pthread_create(&threads[i], NULL, Reader, id);
    }

    // 创建写者线程
    for (int i = reader_num; i < total; ++i)
    {
        int* id = new int(i - reader_num);
        pthread_create(&threads[i], NULL, Writer, id);
    }

    // 等待所有线程完成
    for (int i = 0; i < total; ++i)
    {
        pthread_join(threads[i], NULL);
    }

    pthread_rwlock_destroy(&rwlock); // 销毁读写锁

    return 0;
}

Makefile

**reader_writer_lock_test:reader_writer_lock_test.cc **

**g++ -o $@ $^ -lpthread **

**.PHONY:clean **

**clean: **

rm -f reader_writer_lock_test

部分运行效果

$ ./reader_writer_lock_test

**写者- 0 正在写入. 新的数据是: 82 **

**读者-0 正在读取数据, 数据是: 82 **

**写者- 0 正在写入. 新的数据是: 32 **

**读者-0 正在读取数据, 数据是: 32 **

**写者- 0 正在写入. 新的数据是: 30 **

**读者-0 正在读取数据, 数据是: 30 **

**写者- 0 正在写入. 新的数据是: 27 **

**读者-0 正在读取数据, 数据是: 27 **

**写者- 0 正在写入. 新的数据是: 43 **

**读者-0 正在读取数据, 数据是: 43 **

写者- 0 正在写入. 新的数据是: 47

3 -> 读者优先(Reader-Preference)

在这种策略中，系统会尽可能多地允许多个读者同时访问资源(比如共享文件或数据)，而不会优先考虑写者。这意味着当有读者正在读取时，新到达的读者会立即被允许进入读取区，而写者则会被阻塞，直到所有读者都离开读取区。读者优先策略可能会导致写者饥饿(即写者长时间无法获得写入权限)，特别是当读者频繁到达时。

4 -> 写者优先(Writer-Preference)

在这种策略中，系统会优先考虑写者。当写者请求写入权限时，系统会尽快地让写者进入写入区，即使此时有读者正在读取。这通常意味着一旦有写者到达，所有后续的读者都会被阻塞，直到写者完成写入并离开写入区。写者优先策略可以减少写者等待的时间，但可能会导致读者饥饿(即读者长时间无法获得读取权限)，特别是当写者频繁到达时。

感谢各位大佬支持！！！

互三啦！！！