C++ getter/setter、互斥量、细粒度锁定

Question

我有一个被多个线程共享的对象，我想锁定单个成员变量，而不是锁定整个对象，以便不同的线程可以同时访问不同的成员变量。阅读一些文章后，我使用 shared_mutex 和 getter()/setter() 函数编写代码。

    class Test
    {
    public:
    **// variable, shared_mutex and getter/setter for x**
    double x;
    boost::shared_mutex x_mutex;
    double x_getter();
    void x_setter();
    **// variable, shared_mutex and getter/setter for y**
    ......
    **// variable, shared_mutex and getter/setter for z**
    ......
    };

    double Test::x_getter()
    {
      // get shared access
      boost::shared_lock lock(_access);
      return x;
    }

    void Test::x_setter()
    {
      // get exclusive access
      boost::unique_lock lock(_access);
      // do something with x;
    }

    //getter/setter functions for y and z. 
    ......

代码看起来很笨拙，尤其是当成员变量的数量增加时。我想知道对于这类问题是否有更好的解决方案。

谢谢。

Answer 1

由于您显然只在实际读取/写入数据的短时间内需要锁定，因此您可以将其与受控数据一起封装到一个类型中，然后将其用作成员变量:

// note: you probably should add constructors as well
template<typename T> struct synchronized
{
public:
  synchronized& operator=(T const& newval)
  {
    boost::unique_lock lock(mutex);
    value = newval;
  }
  operator T() const
  {
    boost::unique_lock lock(mutex);
    return value;
  }
private:
  T value;
  boost::shared_mutex mutex;
};

class Test
{
public:
  synchronized<double> x;
  synchronized<int> y;
  synchronized<std::string> z;
};

void foo(Test& t)
{
  double read = t.x; // locked, via synchronized<double>::operator double() const
  t.x = 3.14;        // locked, via synchronized<double>::operator=
}