读者写者问题读者优先和写者优先c++代码

下面是读者优先的读者写者问题C++代码示例：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;

mutex mtx;
condition_variable cv;
int read_count = 0;
bool writing = false;

void reader(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        // 等待写者释放锁
        while (writing) {
            cv.wait(lock);
        }
        // 读者进程数加一
        read_count++;
        cout << "Reader " << id << " is reading" << endl;
        // 释放锁
        lock.unlock();
        // 读者进程阻塞一段时间
        this_thread::sleep_for(chrono::milliseconds(100));
        // 再次获取锁
        lock.lock();
        // 读者进程数减一
        read_count--;
        // 如果没有读者进程了，通知写者进程
        if (read_count == 0) {
            cv.notify_one();
        }
        // 释放锁
        lock.unlock();
        // 读者进程阻塞一段时间
        this_thread::sleep_for(chrono::milliseconds(50));
    }
}

void writer(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        // 等待其他读者或写者释放锁
        while (writing || read_count > 0) {
            cv.wait(lock);
        }
        // 标记为正在写入
        writing = true;
        cout << "Writer " << id << " is writing" << endl;
        // 标记为不在写入
        writing = false;
        // 通知其他读者或写者可以获取锁了
        cv.notify_all();
        // 释放锁
        lock.unlock();
        // 写者进程阻塞一段时间
        this_thread::sleep_for(chrono::milliseconds(200));
    }
}

int main() {
    thread r1(reader, 1);
    thread r2(reader, 2);
    thread r3(reader, 3);
    thread w1(writer, 1);
    thread w2(writer, 2);
    r1.join();
    r2.join();
    r3.join();
    w1.join();
    w2.join();
    return 0;
}

在上面的代码中，读者进程在访问共享资源之前增加读者进程数，访问完成后减少读者进程数，如果没有读者进程了，则通知写者进程。写者进程在访问共享资源之前等待读者进程释放锁，访问完成后通知其他读者进程和写者进程可以访问共享资源了。

下面是写者优先的读者写者问题C++代码示例：

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
using namespace std;

mutex mtx;
condition_variable cv;
int read_count = 0;
int write_count = 0;

void reader(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        // 等待写者释放锁或没有写者进程
        while (write_count > 0) {
            cv.wait(lock);
        }
        // 读者进程数加一
        read_count++;
        cout << "Reader " << id << " is reading" << endl;
        // 读者进程数减一
        read_count--;
        // 如果没有读者进程了，通知写者进程
        if (read_count == 0) {
            cv.notify_one();
        }
        // 释放锁
        lock.unlock();
        // 读者进程阻塞一段时间
        this_thread::sleep_for(chrono::milliseconds(100));
    }
}

void writer(int id) {
    while (true) {
        unique_lock<mutex> lock(mtx);
        // 写者进程数加一
        write_count++;
        // 等待其他读者或写者释放锁
        while (read_count > 0 || write_count > 1) {
            cv.wait(lock);
        }
        // 标记为正在写入
        cout << "Writer " << id << " is writing" << endl;
        // 标记为不在写入
        writing = false;
        // 写者进程数减一
        write_count--;
        // 通知其他读者或写者可以获取锁了
        cv.notify_all();
        // 释放锁
        lock.unlock();
        // 写者进程阻塞一段时间
        this_thread::sleep_for(chrono::milliseconds(200));
    }
}

int main() {
    thread r1(reader, 1);
    thread r2(reader, 2);
    thread r3(reader, 3);
    thread w1(writer, 1);
    thread w2(writer, 2);
    r1.join();
    r2.join();
    r3.join();
    w1.join();
    w2.join();
    return 0;
}

在上面的代码中，写者进程在访问共享资源之前等待其他读者进程和写者进程释放锁，访问完成后通知其他读者进程和写者进程可以访问共享资源了。读者进程在访问共享资源之前等待写者进程释放锁或没有写者进程，访问完成后如果没有读者进程了，则通知写者进程。