C++ 实现有界缓冲区（读写器之间的非块、读写器之间的块、写写器之间的块）

实现有界队列

阅读：
如果队列为空，请等待它返回超时值
如果另一个线程正在从队列中读取，则等待该线程完成
从队列中删除第一个元素并返回它
如果线程正在写入队列，请不要阻止

写入：
如果队列已满，等待读取一个值并超时
如果另一个线程正在写入队列，请等待该线程完成
在队列末尾写入元素
如果线程正在从队列中读取，则不要阻止

我不确定我的实现是否正确

using namespace std;

template <typename T, int N>
class BoundedBuffer {
private:
    std::array<T, N> buffer;
    int read_pos;
    int write_pos;

    std::mutex reader_mutex; //mutex for between readers
    std::mutex writer_mutex; //mutex for between writers

    std::mutex shared_mutex;
    std::condition_variable reader_queue;
    std::condition_variable writer_queue;
    int timeout; //timeout in millisecond


public:
    BoundedBuffer(const BoundedBuffer&) = delete;
    BoundedBuffer& operator=(const BoundedBuffer&) = delete;

    BoundedBuffer(int t) :
        read_pos(0),
        write_pos(0),
        timeout(t) {
    }

    inline bool empty() {
        return read_pos == write_pos;
    }

    inline bool full() {
        return write_pos >= read_pos + N;
    }

    bool put(const T& data) {
        unique_lock<mutex> writer_lock(writer_mutex);

        {
            unique_lock<mutex> shared_lock(shared_mutex);
            if (full()) { //buffer full
                if (writer_queue.wait_for(shared_lock, std::chrono::milliseconds(timeout)) ==
                    std::cv_status::timeout)
                    return false;
            }
        }

        buffer[write_pos%N] = data;
        write_pos++;
        reader_queue.notify_one();
        return true;
    }

    pair<T, bool> get() {
        unique_lock<mutex> reader_lock(reader_mutex);

        {
            unique_lock<mutex> shared_lock(shared_mutex);
            if (empty()) { //buffer empty
                if (reader_queue.wait_for(shared_lock, std::chrono::milliseconds(timeout)) ==
                    std::cv_status::timeout) {
                    T t;
                    return make_pair(t, false);
                }
            }
        }

        pair<T, bool> result = make_pair(buffer[read_pos%N], true);
        read_pos++;
        writer_queue.notify_one();
        return result;
    }
};

使用名称空间std；
模板
类边界缓冲区{
私人：
std：：数组缓冲区；
int read_pos；
int write_pos；
std:：mutex reader\u mutex；//读取器之间的互斥
std:：mutex writer\u mutex；//编写器之间的互斥
std：：互斥体共享_互斥体；
std：：条件变量读取器队列；
std:：条件变量写入器队列；
int timeout；//以毫秒为单位的超时
公众：
BoundedBuffer（const BoundedBuffer&）=删除；
BoundedBuffer&运算符=（const BoundedBuffer&）=删除；
BoundedBuffer（int t）：
读取位置（0），
写入位置（0），
超时（t）{
}
内联bool empty（）{
返回read_pos==write_pos；
}
内联布尔满（）{
返回write_pos>=read_pos+N；
}
布尔输出（常数T和数据）{
唯一的写入锁写入锁（写入锁互斥锁）；
{
唯一锁共享锁（共享互斥锁）；
if（full（））{//缓冲区已满
if（writer_queue.wait_for（共享锁，std:：chrono:：毫秒（超时））==
标准：：cv_状态：：超时）
返回false；
}
}
缓冲区[写入位置%N]=数据；
写_pos++；
读卡器队列。通知一个（）；
返回true；
}
pair get（）{
唯一的读卡器锁（读卡器互斥锁）；
{
唯一锁共享锁（共享互斥锁）；
if（empty（））{//缓冲区为空
if（读卡器队列。等待（共享锁，标准：：时钟：：毫秒（超时））==
标准：：cv_状态：：超时）{
T；
返回make_对（t，false）；
}
}
}
配对结果=配对（缓冲区[读取位置%N]，真）；
读_pos++；
writer_queue.notify_one（）；
返回结果；
}
};

在我的代码中发现一个错误：
在put（）和get（）方法中，它调用wait_for（）并检查返回值。
如果是超时，则返回false，否则它假定满足等待条件，代码继续放入/获取数据。
如果wait_for（）由于虚假唤醒而返回，并且在不满足条件时：
put（）未满，get（）未空，
然后它将覆盖现有数据或读取错误数据

修复方法是在wait_for（）中使用谓词。它将忽略虚假的唤醒

    bool put(const T& data) {
            unique_lock<mutex> writer_lock(writer_mutex);

            {
                    unique_lock<mutex> shared_lock(shared_mutex);
                    if (full()) { //buffer full
                            if (writer_queue.wait_for(shared_lock, std::chrono::milliseconds(timeout),
                                    [this]() { return !full(); }) == false) {
                                    return false;
                            }
                    }
            }

            buffer[write_pos%N] = data;
            write_pos++;
            reader_queue.notify_one();
            return true;
    }


    pair<T, bool> get(int i) {
            unique_lock<mutex> reader_lock(reader_mutex);
            cout << "i : " << i << endl;

            {
                    unique_lock<mutex> shared_lock(shared_mutex);
                    if (empty()) { //buffer empty
                            if (reader_queue.wait_for(shared_lock, std::chrono::milliseconds(timeout),
                                    [this]() { return !empty(); })==false) {
                                    T t;
                                    return make_pair(t, false);
                            }
                    }
            }

            pair<T, bool> result = make_pair(buffer[read_pos%N], true);
            read_pos++;
            writer_queue.notify_one();
            return result;
    }

bool put（常量和数据）{
唯一的写入锁写入锁（写入锁互斥锁）；
{
唯一锁共享锁（共享互斥锁）；
if（full（））{//缓冲区已满
if（writer_queue.wait_for）（共享锁，std:：chrono:：毫秒（超时），
[this]（）{return！full（）；}）==false）{
返回false；
}
}
}
缓冲区[写入位置%N]=数据；
写_pos++；
读卡器队列。通知一个（）；
返回true；
}
配对获取（int i）{
唯一的读卡器锁（读卡器互斥锁）；
库特