c++ - 对于短共享操作和少数独特操作，是否有任何共享互斥锁的方法？

Question

众所周知，std::shared_timed_mutex (C++14) 和 std::shared_mutex (C++17) 比 std 有性能优势: :mutex 仅适用于很长的 std::shared_locks(读操作)，当std::shared_locks超过 std::unique_lock。

但即使它的大部分是读操作，而且它们很短，std::mutex 也会更快——这就是为什么在 C++11 标准中 std::shared_mutex 和 std::shared_timed_mutex 没有立即包含在内。

是否有某种共享互斥体的任何方法或实现，它比 std::mutex 具有性能优势，也对于短操作，如果读取不只是更多，还有更多如下？

std::unique_lock/std::shared_lock = 1/1 000 000 000 000

对于短的共享操作和很少的独特操作，是否有任何共享互斥锁的方法？

Answer 1

一种可能的方法是使用重复数据。这应该可以很好地适应大量读者和少数作者。我不知道它是否比 shared_mutex() 快，但它是另一种选择

基本思想:

每个读者都在一个读者拷贝上工作，而作者可以修改单独的作者拷贝。要提交更改，您将编写器对象存储在一个新的读取器对象中，该读取器对象将从每个新读取器获取。下一次提交将存储到现在旧的读取器对象中。因此作者需要等待，直到所有老读者都释放了对该对象的锁定。

简单的例子:

struct data{
    int a;
};

struct secured_data {
    data read[2];
    data write;
    std::atomic<int> current = 0;
    std::atomic<int> num_read[2] = 0;

    std::mutex m;

    data* read_lock() {
        // increase reader-counter of current data-object
        int c = current.load();
        num_read[c].fetch_add(1);
        // return current copy
        return &read + c;
    }

    void read_unlock(data* old) {
        // decrease the old data-object (which was returned by read_lock())
        num_read[old - &read].fetch_sub(1);


    }

    data* lock() {
        m.lock();
        // every modification happens on a seperate copy
        write = read[current.load()];
        return &write;
    }

    void unlock() {
       int c;
       // wait until all readers using an old copy have released their lock
       do {
           c = current.load();
       } while (num_read[(c + 1) % 2].load() != 0);
       // copy into new read-object
       read[(c + 1) % 2] = write;
       // swap read-object
       // all readers now use an old version
       current.store((c + 1) % 2);
       m.unlock();
    }
}