c++ - 使用互斥量来阻止从临界区外执行

Question

我不确定我的术语是否正确，但这里是 - 我有这个函数被多个线程用来写入数据(在注释中使用伪代码来说明我想要什么)

//these are initiated in the constructor
int* data; 
std::atomic<size_t> size;

void write(int value) {
    //wait here while "read_lock"
    //set "write_lock" to "write_lock" + 1
    auto slot = size.fetch_add(1, std::memory_order_acquire);
    data[slot] = value;
    //set "write_lock" to "write_lock" - 1
}

写入的顺序并不重要，我在这里只需要每次写入都进入一个唯一的插槽

虽然每隔一段时间，我需要一个线程来使用这个函数读取数据

int* read() {
    //set "read_lock" to true
    //wait here while "write_lock"
    int* ret = data;
    data = new int[capacity];
    size = 0;
    //set "read_lock" to false
    return ret;
}

所以它基本上换掉了缓冲区并返回旧的(我删除了容量逻辑以使代码片段更短)

理论上这会导致两种操作场景:

1 - 只是一堆写入容器的线程

2 - 当某个线程执行读取函数时，所有新的写入器都必须等待，读取器将等待所有现有写入完成，然后执行读取逻辑，场景 1 可以继续。

问题部分是我不知道锁使用什么样的屏障 -

自旋锁会很浪费，因为有很多这样的容器，它们都需要 cpu 周期

我不知道如何应用 std::mutex，因为我只希望在触发读取函数时将写入函数放在临界区中。将整个写入函数包装在互斥量中会导致操作场景 1 不必要的减速。

那么这里的最佳解决方案是什么？

Answer 1

如果您有 C++14 能力，那么您可以使用 std::shared_timed_mutex将读者和作者分开。在这种情况下，您似乎需要为您的写入线程共享访问权限(同时允许其他写入线程)和您的读取线程唯一访问权限(将所有其他线程踢出).

所以你可能需要这样的东西:

class MyClass
{
public:
    using mutex_type = std::shared_timed_mutex;
    using shared_lock = std::shared_lock<mutex_type>;
    using unique_lock = std::unique_lock<mutex_type>;

private:
    mutable mutex_type mtx;

public:

    // All updater threads can operate at the same time
    auto lock_for_updates() const
    {
        return shared_lock(mtx);
    }

    // Reader threads need to kick all the updater threads out
    auto lock_for_reading() const
    {
        return unique_lock(mtx);
    }
};

// many threads can call this
void do_writing_work(std::shared_ptr<MyClass> sptr)
{
    auto lock = sptr->lock_for_updates();

    // update the data here
}

// access the data from one thread only
void do_reading_work(std::shared_ptr<MyClass> sptr)
{
    auto lock = sptr->lock_for_reading();

    // read the data here
}

shared_lock s 允许其他线程获得 shared_lock同时但要防止unique_lock获得同时访问。当读者线程试图获得 unique_lock所有shared_lock s 将在 unique_lock 之前腾出获得独占控制权。