在运行时选择互斥体或虚拟互斥体

像这样的怎么样? 它未经测试,但应该接近正常。 您可以考虑让模板类保存一个值而不是指针 如果互斥体支持正确的构造类型。否则,您可以专门化mymutex类以获得值行为。

另外,它也不小心复制或销毁。我把它作为练习留给读者;)(共享或存储值而不是指针应该可以解决这个问题)

哦,使用RAII代码会更好,而不是显式的锁定/解锁…但这是一个不同的问题。我想这就是你代码中的唯一锁的作用?

struct IMutex
{
  virtual ~IMutex(){}
  virtual void lock()=0;
  virtual bool try_lock()=0;
  virtual void unlock()=0;
};

template<typename T>
class MyMutex : public IMutex
{
  public:
    MyMutex(T t) : t_(t) {}
    void lock() { t_->lock(); }
    bool try_lock() { return t_->try_lock(); }
    void unlock() { t_->unlock(); }
  protected:
    T* t_;
};

IMutex * createMutex()
{
  if( isMultithreaded() )
  {
     return new MyMutex<boost::mutex>( new boost::mutex );
  }
  else
  {
     return new MyMutex<signal2::dummy_mutex>( new signal2::dummy_mutex );
  }
}


int main()
{
   IMutex * mutex = createMutex();
   ...
   {
     unique_lock<IMutex> guard( *mutex );
     ...
   }

}

因为这两个互斥类 signals2::dummy_mutex 和 boost::mutex 不要共享一个公共的基类,你可以使用类似的 external polymorphism 允许他们接受多态性治疗。然后你就把它们当作锁 strategies 对于一个通用的互斥锁接口。这允许您避免使用“ if “锁实现中的语句。

注释 :这基本上就是迈克尔提出的解决方案所实现的。我建议你接受他的回答。

你听说过吗 Policy-based Design ?

您可以定义 Lock Policy 界面,用户可以选择自己想要的策略。为了便于使用,“默认”策略使用编译时变量进行精确定义。

#ifndef PROJECT_DEFAULT_LOCK_POLICY
#define PROJECT_DEFAULT_LOCK_POLICY TrueLock
#endif

template <class LP = PROJECT_DEFAULT_LOCK_POLICY>
class MyClass {};

这样,您的用户可以使用一个简单的编译时开关来选择他们的策略,并且可以一次覆盖一个实例;)

这还不够吗?

   class SomeClass
    {
    public:
        SomeClass(void);
        ~SomeClass(void);
        void Work(bool isMultiThreaded = false)
        {
            if(isMultiThreaded)
           {
               lock // mutex lock ...
               {
                    DoSomething
               }
           }
           else
           {
                DoSomething();
           }
       }   
    };

通常,只有在多个进程之间共享资源时才需要互斥。如果对象的实例对于一个(可能是多线程的)进程是唯一的,那么关键部分通常更合适。

在Windows中,关键部分的单线程实现。 是 一个假的。不确定您使用的平台。

仅供参考,这里是我最终的实现。

我去掉了抽象基类,将其与no-op“dummy”实现合并。还注意到 shared_ptr -具有隐式转换运算符的派生类。我觉得有点太棘手了,但它让我 shared_ptr<IMutex> 我以前使用过的对象 boost::mutex 零更改的对象。

头文件:

class Foo {
   ...
private:
    struct IMutex {
        virtual ~IMutex()       { }
        virtual void lock()     { }
        virtual bool try_lock() { return true; }
        virtual void unlock()   { }
    };
    template <typename T> struct MutexProxy;

    struct MutexPtr : public boost::shared_ptr<IMutex> {
        operator IMutex&() { return **this; }
    };

    typedef boost::unique_lock<IMutex> MutexGuard;

    mutable MutexPtr mutex;
};

实施文件:

template <typename T>
struct Foo::MutexProxy : public IMutex {
    virtual void lock()     { mutex.lock(); }
    virtual bool try_lock() { return mutex.try_lock(); }
    virtual void unlock()   { mutex.unlock(); }
private:
    T mutex;
};

Foo::Foo(...) {
    mutex.reset(single_thread ? new IMutex : new MutexProxy<boost::mutex>);
}

Foo::Method() {
    MutexGuard guard(mutex);
}

这是我的解决方案:

std::unique_lock<std::mutex> lock = dummy ?
     std::unique_lock<std::mutex>(mutex, std::defer_lock) :
     std::unique_lock<std::mutex>(mutex);