c++ - 将多线程类重构为单线程+和多线程

我有一个以这种方式实现的多线程 C++ 类:

class MyClass{
protected:
  somemutex mutex;
  void _unsafeMethod(){...};
public:
  void safeMethod{
    locker lock(mutex);
    _unsafeMethod();
  }
}

我对此很满意，但注意到在大多数情况下，多线程支持并不是真正必要的，所以我想将其分为 2 个类:一个线程安全类，一个不安全但性能更好的类。

问题是，使用该类的代码有数千行，所以我需要保持界面相同。当然，类名的定义会有所变化，这取决于它是否需要支持 MT。

我想到了以下内容:

解决方案 A

class MyClass{
protected:
  void _unsafeMethod(){...};
public:
  virtual void safeMethod{
    _unsafeMethod()
  };
};
class MyThreadSafeClass: public MyClass{
protected:
  somemutex mutex;
public:
  virtual void safeMethod{
    locker lock(mutex);
    _unsafeMethod();
  };
}

这里的问题是虚函数调用:它是否使执行速度变慢，所以我立即失去了单线程类性能改进的好处？从第一次测试它看起来像

解决方案 B

class MyClass{
protected:
  somemutex * pmutex;
  void _unsafeMethod(){...};
public:
  MyClass( bool isthreadsafe ){
    if( isthreadsafe )
       pmutex = new somemutex();
    else
       pmutex = NULL;
  };
  void safeMethod{
    if( pmutex )
    {
       locker lock(*pmutex);
       _unsafeMethod();
    }
    else
      _unsafeMethod();
  };
}

第二个解决方案看起来很脏，并且每次调用中总是有一个“如果”需要解决。

您认为哪种解决方案更有效？您有没有想到更好/更清洁/性能更好的解决方案？

非常感谢!

最佳答案

您可以使用装饰器模式或包装器。 .

A ]一个修改过的包装器，这样你就可以摆脱虚函数:

class MyClass{
protected:
  void _unsafeMethod(){};

};

class MyThreadSafeClass{
protected:
  somemutex mutex;
  MyClass& myclassRef;
public:
    MyThreadSafeClass(MyClass& myclass):myclassRef(myclass){}
  void safeMethod(){
    locker lock(mutex);
    myclassRef._unsafeMethod();
  }
};

类调用:

MyClass myclass;
MyThreadSafeClass mythreadsafeclass(myclass);
mythreadsafeclass.safeMethod();

B ] 具有虚拟接口(interface)的装饰器:

class MyClassInterface{
public:
  virtual void Method()=0;

};

class MyClass : public MyClassInterface{
protected:
  virtual void Method() override{};

};

class MyThreadSafeClass: public MyClassInterface{
protected:
  somemutex mutex;
  MyClassInterface& myclassRef;
public:
    MyThreadSafeClass(MyClassInterface& myclass):myclassRef(myclass){}
   virtual void Method() override{
     locker lock(mutex);
     myclassRef.Method();
  }
};