#include <iostream>
#include <mutex>
#include <condition_variable>

class ReadWriteLock {
private:
    std::mutex mutex_;
    std::condition_variable read_cv_;
    std::condition_variable write_cv_;
    int readers_;
    bool writing_;

public:
    ReadWriteLock() : readers_(0), writing_(false) {}

    void lockRead() {
        std::unique_lock<std::mutex> lock(mutex_);
        // 如果有線程正在進行寫操作或者等待寫操作，則阻塞等待
        while (writing_) {
            read_cv_.wait(lock);
        }
        readers_++;
    }

    void unlockRead() {
        std::unique_lock<std::mutex> lock(mutex_);
        readers_--;
        if (readers_ == 0) {
            write_cv_.notify_one(); // 喚醒等待寫操作的線程
        }
    }

    void lockWrite() {
        std::unique_lock<std::mutex> lock(mutex_);
        // 如果有線程正在讀或?qū)?，則阻塞等待
        while (writing_ || readers_ > 0) {
            write_cv_.wait(lock);
        }
        writing_ = true;
    }

    void unlockWrite() {
        std::unique_lock<std::mutex> lock(mutex_);
        writing_ = false;
        read_cv_.notify_all();  // 喚醒等待讀操作的線程
        write_cv_.notify_one(); // 喚醒等待寫操作的線程
    }
};

// 示例用法
ReadWriteLock rwLock;

void readerFunction(int id) {
    while (true) {
        rwLock.lockRead();
        // 執(zhí)行讀取操作
        std::cout << "Reader " << id << " is reading" << std::endl;
        rwLock.unlockRead();
        // 休眠一段時間模擬讀取過程
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

void writerFunction(int id) {
    while (true) {
        rwLock.lockWrite();
        // 執(zhí)行寫入操作
        std::cout << "Writer " << id << " is writing" << std::endl;
        rwLock.unlockWrite();
        // 休眠一段時間模擬寫入過程
        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
    }
}

int main() {
    // 創(chuàng)建多個讀者線程和寫者線程進行測試
    std::thread readers[3];
    std::thread writers[2];

    for (int i = 0; i < 3; i++) {
        readers[i] = std::thread(readerFunction, i);
    }

    for (int i = 0; i < 2; i++) {
        writers[i] = std::thread(writerFunction, i);
    }

    // 等待所有線程結(jié)束
    for (auto& reader : readers) {
        reader.join();
    }

    for (auto& writer : writers) {
        writer.join();
    }

    return 0;
}