c++ - 这种做法线程安全吗？

Question

假设我有一个这样的类..这只是一个抽象代码

class foo
{
public:
  int a;
  static foo* pfoo;
  foo()
  {
    pfoo = this;
  }
  fooCar* pFooCar;
  void someMethod();
}

现在其他一些类可能会这样做

foo::pfoo->someMethod();  

或

foo::pfoo->a = 14;

这种做法是否正确？

我是否应该将类的静态变量设为私有(private)并将静态变量的 getter 包装在互斥锁中？

像这样

class foo
{
private:
static foo* pfoo;
public:
  int a;
  foo()
  {
    pfoo = this;
  }
  static foo* getFoo()
  {
      lock mutex..
      return pfoo
      unlock mutex..
  }
  fooCar* pFooCar;
  void someMethod();
}

还有其他建议吗？

Answer 1

首先，你的静态 pfoo 基本上只是单例模式，所以你可以用这个(Meyers singleton)替换那个 pfoo 东西，这是保证安全的(如果你想在之后更改指针，则这不适用):

class foo {
public:
    static foo* getFoo() {
        static foo singleton;
        return &singleton;
    }
};

但是，任何您在收到指针后所做的事情都不能保证是线程安全的。但这完全取决于您对代码的需求。线程安全性因应用程序而异很多，尤其是读者和作者的数量。

现在，如果您只想让一个线程一次访问 foo 的成员，那么您可以只使用一个互斥量:

class foo {
std::mutex fooMutex;
int bar;
public:
    static foo* getFoo() {
        static foo singleton;
        return &singleton;
    }

    void setBar(int newBar) {
        std::lock_guard guard(fooMutex); //This goes in every function that modifies the data.
        bar = newBar;
    }

    int getBar() {
        std::lock_guard guard(fooMutex); //If simultaneous readers are allowed then remove this
        return bar;
    }
};

这完全取决于您的用例。这只是执行此操作的最简单、最幼稚且效率最低的方法。例如，如果您需要根据当前值更改 bar 的值，这将不起作用。