关于std::shared_mutex的问题：threads/reader can't read variable同时

Question

这是我的代码

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <windows.h>

using namespace std;
class Counter {
public:
    Counter() : value_(0) {
    }

    // Multiple threads/readers can read the counter's value at the same time.
    std::size_t Get() const {
        std::shared_lock<std::shared_mutex> lock(mutex_);
        std::cout << std::this_thread::get_id() << ' ' << value_ << std::endl;
        Sleep(1000);
        return value_;
    }

    // Only one thread/writer can increment/write the counter's value.
    void Increase() {
        // You can also use lock_guard here.
        std::unique_lock<std::shared_mutex> lock(mutex_);
        value_++;
        lock.unlock();
    }

private:
    mutable std::shared_mutex mutex_;
    std::size_t value_;
};



void Worker(Counter& counter) {
    counter.Get();
    counter.Increase();
    counter.Get();
}

#include <vector>
int main() {
    Counter counter;
    std::vector<std::thread> v;
    for(int i(0);i<10;i++){v.emplace_back(&Worker, std::ref(counter));}
    for (std::thread& t : v) t.join();
    return 0;
}

结果是这样的：

12188457610048 10196 06744
3692  0011812 8392 6912  00
10392 00
0

0
0



6744 1
3692 2
11812 3
10048 4
4576 5
10392 6
8392 7
10196 8
12188 9
6912 10

这很奇怪：第一次运行“counter.Get()”时，所有读取线程都在同时读取。但是第二次，使用“counter.Increase”后再次运行“counter.Get()” ()",所有读者线程只需要等待 1 秒即可得到答案。这是为什么？有什么办法可以解决吗？

Answer 1

因为链接

如果一个线程已经获得了共享锁（通过lock_shared，try_lock_shared），其他线程不能获得排他锁，但可以获得共享锁。

First Get对所有工作人员同时运行，因为只获取shared_lock 。 但是， Increase操作需要排他锁。 现在，从Increase操作释放独占锁后，您立即在第二个Get操作中获取共享锁，这导致所有尚未调用Increase的线程等待1 秒，直到Get释放锁。

Answer 2

在作家释放锁定后，哪个线程获取互斥锁的机会不相等，因此在您的情况下，同一个线程可能会再次获取它。 当读者使用互斥锁时，作者一直在等待。

这叫不公平。 相反，公平互斥体会给其他线程一些机会。

C++ 标准没有定义 C++ 互斥体是公平的还是不公平的。

通常它们是不公平的，因为不公平的互斥锁通常对性能更好。