受保护的资源需要return by getter作为现代c++中的shared_ptr，如何设计单写多读？

Question

我有一个写入器线程写入对象中的地图，许多 reader 对象各自在自己的线程中在地图上执行只读，我当前的设计如下所示，

class MyClass {
private:
    shared_ptr<map<int, int>> my_map;
    mutable shared_mutex mu;
public:
    void update_or_add(pair<int, int> entry);
    shared_lock<shared_mutex> get_read_lock();
    shared_ptr<const map<int, int>> get_map();
}


void MyClass::update_or_add(pair<int, int> entry) {
    lock_guard<shared_mutex> locker(mu);
    // do update on my_map
}

shared_lock<shared_mutex> MyClass::get_read_lock() {
    shared_lock<shared_mutex> locker(mu);
    return locker;

shared_ptr<const map<int, int>> MyClass::get_map() {
    return my_map;
}

以下是我的使用方法

//writer
//thread-1
MyClass obj;
while(true) 
obj.update_or_add(entry);

//readers
//thread-2
shared_lock<shared_mutex> locker(obj.get_read_lock());
auto mymap = obj.get_map();
//some computation on mymap
....
//thread-n
shared_lock<shared_mutex> locker(obj.get_read_lock());
auto mymap = obj.get_map();
//some computation on mymap

我有两个问题，

这是使用 shared_lock 和 shared_mutex 的正确方法吗？
因为想实现read的并发，所以把map的指针返回给其他object做计算，有没有更好的设计？

谢谢。

Answer 1

这是一个非常简单的共享资源：

template<class T>
struct shared_threadsafe {
  template<class F>
  auto read(F&& f)const{
    auto l = lock(); // shared lock
    return f(t); // const access
  }
  template<class F>
  auto write(F&& f){
    auto l = lock(); // exclusive lock
    return f(t); // non-const access
  }
  // construct from a T
  explicit shared_threadsafe( T in ):t(std::forward<T>(in)){}
  // default construct
  shared_threadsafe()=default;
  shared_threadsafe(shared_threadsafe const&)=delete; // it can be written, but don't
  shared_threadsafe& operator=(shared_threadsafe const&)=delete; // it can be written, but don't
  ~shared_threadsafe()=default;
private:
  mutable std::shared_mutex m;
  T t;
  auto lock() const { return std::shared_lock{m}; }
  auto lock() { return std::unique_lock{m}; }
}

它使用 c++17 非常简短。对打字错误表示歉意。

你有一个：

shared_threadsafe<std::map<int,int>> bob;

作者线程：

bob.write([&](auto& bob){ bob.insert( p ); });

reader 话题:

bob.read([&](auto& bob){
  // cos=de that reads from the map `bob`
});

如果 reader 个线程有 const 个引用或指针，它们只有读取权限。

在实践中，我会想一些操作，让共享线程安全在某些 class 中是私有的，并且只公开那些操作。

通常公开完整的 read/write 锁表明您的代码还不够高级。基于锁的并发既不能组合也不能很好地扩展。当您将能力暴露给锁中的运行任意代码时，您鼓励组合，这是一场灾难。

我的共享线程安全是一种尝试性的妥协，因为至少锁定代码只写一次并且是基于作用域的。我把它隐藏了，因为它仍然没有合成。

根据您的 read/write 操作和延迟成本，转移到争用版本的副本也可能是明智的。在这个计划下，readers 得到智能指针指向 table 他们有完整的 const 访问权限。如果存在争用，写入器会在写入（牛）中进行复制，否则会进行快速更新。写入时复制结果仅对写入发生后出现的 reader 可见。

一个手写的(non-std) map可以做partial cow update，共享table新老reads不变的部分

但此时，您开始考虑数据库。无论如何，也许你应该从哪个开始。

受保护的资源需要return by getter作为现代c++中的shared_ptr，如何设计单写多读？

how to design a single write and multiple read when the protected resource need to be return by getter as a shared_ptr in modern c++?

c++

concurrency

mutex

c++14

c++17