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=
}

Answer 2

你是对的，这种方法看起来确实很笨拙，而且很快就会变得难以管理。因此，我尝试通过打破数据依赖性来建模多线程问题。但是，如果没有进一步了解您要解决的问题，我无法建议如何对问题进行建模。

如果您已经投资了这样的架构并且改变已经太晚了，那么我会考虑这一点。

template<class T>
class SharedValiable
{
    private:
        T                    myT;
        boost::shared_mutex  myTMutex;

    public:
        //
        // Implement appropriate copy, assign and default 
        // to ensure proper value semantics
        //

        T getter() const
        {
            boost::shared_lock lock(_access);
            return x;
        }

        void setter()
        {
            boost::unique_lock lock(_access);
        }
}

这允许每个变量按照您最初的预期受到保护，但更容易添加新成员或从类中删除成员。此外，模板可以专门用于可以使用原子操作系统操作（例如整数）的某些类型。例如：

template<int>
class SharedValiable
{
    private:
        T                    myT;

    public:
        //
        // Implement appropriate copy, assign and default 
        // to ensure proper value semantics
        //

        T getter() const
        {
            // no need to lock, updates are atomic
            return x;
        }

        void setter()
        {
            // no mutex needed we will use an atomic OS op to update
            InterlockedCompareAndExchange(myT, newVal);
        }
}

Answer 3

一般来说，我建议不要这样做。通常，您尝试对类执行的操作是确保在进入和离开方法时对对象的状态提供某种保证。例如，在列表对象中，您需要链接处于一致状态，需要计数正确等等。仅锁定单个变量很少会导致这种情况发生。如果您更改链接而不锁定计数状态，那么当更新过程中另一个线程查询该链接时，您就对其中一个或另一个撒谎了。更糟糕的是，您可能会同时更改两个链接，最终会得到一个不再有效的混乱列表，具体取决于您的存储空间。当然，这只是可能的例子之一，但您应该明白这一点。

如果您希望多个线程能够查看对象的状态，那么您需要对整个对象进行读取器/写入器锁定，这将允许任意数量的读取器，但不允许他们在更新中查看对象。