C++ 线程安全括号运算符代理

Question

给定一个标准向量的简单包装器，以线程安全的方式实现operator[] 以便能够像往常一样设置内容的好方法是什么？

struct bracket_operator_proxy;

struct example
{
    auto operator[](size_t i) const { return bracket_operator_proxy(v, m, i); }
private:
    std::vector<double> v;
    std::mutex m;
};

这是我对bracket_operator_proxy 的快速而天真的尝试：

struct bracket_operator_proxy
{
     bracket_operator_proxy(std::vector<double>& v, std::mutex& m, int i)
        : v(v), m(m), i(i) {}

     operator double() const
     {
         std::lock_guard<std::mutex> l(m);
         return v[i];
     }

     auto operator=(double d)
     {
         std::lock_guard<std::mutex> l(m);
         v[i] = d;
         return d;
     }

     //... further assignment operators ...
private:
     std::vector<double>& v;
     std::mutex& m;
     int i;
};

这已经足够了吗？还是我错过了什么会炸掉我的腿？

Answer 1

拥有operator->（非常有用）后，您需要返回一个-> 代理，该代理将锁的生命周期延长到语句结束，并使您面临单线程死锁。

查看线程安全的 monads/functor/wrapper，例如 the one here。它不会使锁完全透明，但它们不应该是。

• 不要在线程之间共享数据

• 如果您共享数据，请使其不可变

• 如果必须对其进行突变，请通过已知安全设计的瓶颈隔离访问。一个消息队列说。

• 如果做不到，请考虑重新设计

• 真的。可能是原子的？

• 有一组有限的函数来明确管理锁

• 好的，现在像上面一样包装在 reader/writer monad 中，使用简单的复合操作

• 编写神奇地获得锁的代码，看起来就像非线程交互代码，从而使您的读者误以为安全和效率

偏好递减。

线程安全的危险和困难的部分不是语法笨拙的事实。正是基于锁的线程安全几乎不可能被证明是正确和安全的。使语法更易于使用并不是一个高价值的目标。

例如，v[i]=v[i+1] 缺乏同步：在读取和写入之间，任何事情都可能发生变化。更别说“i是一个有效的索引吗？”