Question

全部

这是我正在寻找的伪代码：

class A : public Base
{
public:
    virtual int func();
    virtual int other_func();
};

class B : public Base
{
public:
    virtual int func();
    virtual int other_func();
};

class MainFrame
{
public:
    MainFrame();
    Base *CreateObject();
    int StartThread();
    int SomeOtherFunc();
private:
    Base *m_base;
};

MainFrame::MainFrame()
{
    m_base = NULL;
}

Base *MainFrame::CreateObject()
{
    if( <condition1> )
        m_base = new A();
    else
        m_base = new B();
}

int MainFrame::StartThread()
{
    int result;
    while( !TestDestroy() )
    {
        result = m_base->func();
        Sleep( 5000 );
    }
}

int MainFrame::SomeOtherFunc()
{
    m_base->other_func();
}

因此，简而言之：我有2个类A和B，它们是从相同的基类派生的。它们都具有从Base重新定义的2个功能（实际上更多，但这无关紧要）。每个类都位于其自己的DLL中。

我还有一个主GUI应用程序，该应用程序在某些情况下会调用A或B的方法。它也在某个时间点生成线程。该程序在线程中调用A / B类的函数。

现在我想做的是防止func（）执行时执行other_func（）。

我可能应该为此使用互斥锁，但是现在的问题是-我如何设计它？我应该在函数本身内部还是在MainFrame方法内部的调用中实例化互斥锁？在这种情况下，互斥锁是否必须是全局变量？它可以成为Base类的成员吗？

再次，从辅助线程发生的func（）调用应停止对Base的任何其他方法的调用，直到完成为止。

TIA！

这是C ++ 11 / MSVC 2010 / gcc5.4的版本。

[编辑]：

有关示例，请参见以下question并将其与以下代码进行比较：

std::mutex my_mutex;
int MainFrame::StartThread()
{
    int result;
    while( !TestDestroy() )
    {
        std::lock_guard<std::mutex> locker( my_mutex );
        result = m_base->func();
        Sleep( 5000 );
    }
}

int MainFrame::SomeOtherFunc()
{
    std::lock_guard<std::mutex> locker( my_mutex );
    m_base->other_func();
}

这两种解决方案之间有区别吗？它们是否都能满足我的目的-专门运行线程功能，从而阻止其他A / B函数执行？

[/ EDIT]

防止同时运行功能

0 个答案: