我应该使用 const 来使对象线程安全吗？

Question

我编写了一个类，其实例可以由多个线程访问。我使用了一个技巧来记住用户在使用对象之前必须锁定该对象。它涉及仅保留 const 实例。当需要读取或修改敏感数据时，其他类应该调用一个方法（该方法是 const，因此允许）来获取锁定对象的非 const 版本。实际上它返回一个代理对象，其中包含一个指向非常量对象的指针和一个scoped_lock，因此当超出范围时它会解锁该对象。代理对象还重载了operator->因此对对象的访问是透明的。

这样，通过访问未锁定的对象来射击自己的脚就更困难了（总是有 const_cast）。

“聪明的把戏”应该避免，而且无论如何这都很难闻。

这个设计真的很糟糕吗？ 我还能或者应该做什么？

编辑： Getter 是强制锁定的非常量。

Answer 1

基本问题：非常量引用可能存在于其他地方。如果安全地写入，并不意味着它可以安全地读取——您可能会看到中间状态。

此外，某些 const 方法可能（合法地）以线程不安全的方式修改隐藏的内部细节。

分析您实际对对象执行的操作并找到合适的同步模式。

如果您聪明的容器确实对对象有足够的了解，可以通过代理控制它们的所有同步，那么请将这些对象设为私有内部类。

Answer 2

这是很聪明的做法，但不幸的是注定会失败。

spraff 强调的问题是，您可以防止读取，但不能防止写入。

考虑以下顺序：

unsigned getAverageSalary(Employee const& e) {
  return e.paid() / e.hired_duration();
}

如果我们在两个函数调用之间递增 paid 会发生什么？我们得到一个不连贯的值。

问题是您的方案没有明确强制读取锁定。

考虑代理模式的替代方案：对象本身是一组数据，都是私有的。只有 Proxy 类（朋友）可以读/写其数据，并且在初始化 Proxy 时，它会自动获取锁（在对象的互斥锁上）。

class Data {
  friend class Proxy;
  Mutex _mutex;
  int _bar;
};

class Proxy {
public:
  Proxy(Data& data): _lock(data._mutex), _data(data) {}

  int bar() const { return _data._bar; }
  void bar(int b) { _data._bar = b; }

private:
  Proxy(Proxy const&) = delete; // disable copy

  Lock _lock;
  Data& _data;
};

Answer 3

如果我想做你正在做的事情，我会做以下其中一项。

方法一：

shared_mutex m;  // somewhere outside the class

class A
{
private:
    int variable;
public:
    void lock() { m.lock(); }
    void unlock() { m.unlock(); }
    bool is_locked() { return m.is_locked(); }
    bool write_to_var(int newvalue)
    {
        if (!is_locked())
            return false;
        variable = newvalue;
        return true;
    }
    bool read_from_var(int *value)
    {
        if (!is_locked() || value == NULL)
            return false;
        *value = variable;
        return true;
    }
};

方法二：

shared_mutex m;  // somewhere outside the class

class A
{
private:
    int variable;
public:
    void write_to_var(int newvalue)
    {
        m.lock();
        variable = newvalue;
        m.unlock();
    }
    int read_from_var()
    {
        m.lock();
        int to_return = variable;
        m.unlock();
        return to_return;
    }
};

第一种方法效率更高（不是一直加锁-解锁），但是程序可能需要不断检查每次读写的输出，看是否成功。第二种方法自动处理锁定，因此程序员甚至不知道锁在那里。

注意：这不是用于复制粘贴的代码。它展示了一个概念并概述了它是如何完成的。请不要评论说您忘记在某处进行一些错误检查。

Answer 4

这听起来很像 Alexandrescu 的 挥发性想法。你不
使用 const 的实际语义，而是利用
类型系统使用它。在这方面，我更喜欢 Alexandrescu 的使用
volatile 的：const 具有非常明确且易于理解的语义，
颠覆它们肯定会给任何阅读的人带来困惑
或维护代码。 volatile 更合适，因为它没有
明确定义的语义，并且在大多数应用程序的上下文中，不是
用于其他任何事情。

您应该返回一个，而不是返回一个经典的代理对象
智能指针。您实际上可以使用 shared_ptr 来实现这一点，抓取
返回值之前的锁，并在删除器中释放它
（而不是删除对象）；然而，我更担心的是，这
会引起读者的一些困惑，我可能会去
使用自定义智能指针（可能将 shared_ptr 与自定义
实现中的删除器）。 （根据你的描述，我怀疑
无论如何，这更接近您的想法。）