4

我有一个以这种方式实现的多线程 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();
  };
}

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

您认为哪种解决方案更有效？您是否有更好/更清洁/性能更高的解决方案？

非常感谢！

4

3 回答 3

3

一个直接的答案是MyClass在互斥锁类型上使用模板：

template <typename MutexType>
class MyClass{
protected:
  MutextType mutex; 
public:
  void safeMethod{
    locker lock(mutex);
    // stuff
  }
}

然后，您可以使用真正的互斥锁或无操作互斥锁来实例化它，以获得您想要的行为。

于 2013-04-09T17:32:30.377 回答
2

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

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 ] 具有虚拟接口的装饰器：

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();
  }
};
于 2013-04-09T14:06:36.343 回答
1

您可以将互斥锁作为参数传递给构造函数。这将允许您选择锁定机制，而无需修改或复制您希望的每种锁定类型的实现。

class Mutex
{
public:
    virtual void Lock() = 0;
};

class MyClass
{
protected:
    Mutex&   mutex;

public:

    MyClass(Mutex& m) : mutex(m) {}

    void Lock()
    {
        mutex.Lock();
    }
};
于 2013-04-09T14:01:15.400 回答