使用 boost 和 tbb 的 C++ 和 MFC 中的异步调用

ICalculator 接口的替代实现，即执行函数和回调的异步实现，称为 CAsyncCalculator，定义如下：

typedef tbb::concurrent_queue<boost::function<void()>> CallQueue;
class CEventReceiver:public CWnd
{
public:
    CEventReceiver(CallQueue& queue);
    ~CEventReceiver();
    void QueueCall(boost::function<void()> &call);
protected:
    LRESULT OnExecuteCall(WPARAM, LPARAM);
    DECLARE_MESSAGE_MAP()
private:
    CallQueue& m_call_queue;
};

class CAsyncCalculator :
    public CWinThread,
    // Is an ICalculator
    public ICalculator,
    // Implemented in terms of ...
    private ICalculatorEvents
{
public:
    CAsyncCalculator(ICalculatorEvents&);
    ~CAsyncCalculator(void);
    // ICalculator
    bool Start(void);
    int  Add(int a, int b);
    void Factorial(unsigned int a);
    void Stop(void);
protected:
    afx_msg void OnExecuteCall(WPARAM, LPARAM);
    DECLARE_MESSAGE_MAP()
    void QueueCall(boost::function<void()> &call);
private:
    // CWinThread overrides
    BOOL InitInstance();
    int ExitInstance();
    // ICalculatorEvents
    void Started(void);
    void Stopped(void);
    void Result(int);
    void Error(int);
private:
    ICalculatorEvents& m_external_callback;
    boost::shared_ptr <ICalculator> m_calculator_impl;
    CallQueue m_call_queue;
    CallQueue m_callback_queue;
    boost::barrier m_worker_thread_started;    
    CEventReceiver m_event_receiver;
};   

关注点

 在遗忘之前，让我说一下，当你在 MFC 中使用 多重继承 时，最好将 MFC 类放在第一个，如果你不想遇到任何意外的话： 

warning C4407: cast between different pointer to member representations, compiler may generate incorrect code 

编译这行时： 

 ON_THREAD_MESSAGE(UWM_EXECUTE_CALL, OnExecuteCall) 

CAsyncCalculator 是一个派生自 ICalculator 接口的类。我们还从 CWinThread 派生它，并在构造函数中创建一个后台线程。该线程将执行我们的调用。我们有一个并发队列用于在后台线程上执行的调用，另一个队列用于回调。回调需要由调用 ICalculator 接口函数的同一个线程执行，也就是创建 CAsyncCalculator 实例的同一个线程。这就是 CEventReceiver 窗口类发挥作用的地方，它是一个消息处理窗口，在 CAsyncCalculator 的构造函数中创建，它接收回调并执行它们。 

CAsyncCalculator::CAsyncCalculator(ICalculatorEvents& callback):
m_external_callback(callback),
m_worker_thread_started(2),
m_event_receiver(m_callback_queue)
{
    BOOL thread_created = CreateThread();
    m_worker_thread_started.wait();    
} 

我们承认这个 CAsyncCalculator 类有点太拥挤了，它确实有从两个不同线程调用的函数，但请将其视为一个教学示例，而不是您可能想要提交给严格的 OOP 代码审查的东西。 

重要的是，要由后台线程创建包含的 CCalculator 对象实例，所有对 CCalculator 实例的调用都将在此执行，并且所有回调都将从此触发。

BOOL CAsyncCalculator::InitInstance()
{
    m_calculator_impl = boost::shared_ptr<ICalculator>(new CCalculator(*this));
    m_worker_thread_started.wait();
    return TRUE;
}

CAsyncCalculator 类中 ICalculator 接口的实现揭示了调用被打包、封送并排队在不同线程上执行的机制。

bool CAsyncCalculator::Start(void)
{
    boost::packaged_task<bool> task(boost::bind(&ICalculator::Start,m_calculator_impl.get()));    
    boost::unique_future<bool> f = task.get_future();
    QueueCall(MoveTaskIntoFunction<bool>(task));
    
    // Timed wait
    if (!f.timed_wait(CALL_TIMEOUT))
    {
        throw std::runtime_error("Start call timeout.");
    }
    return f.get();
} 

 上面您可以看到我们想要同步执行调用，但有一个超时作为我们允许等待执行完成的最大时长。 

MoveTaskIntoFunction 是一件大事，我们将其归功于 **D Drmmr**。您可以在 这里 阅读更多关于该主题的内容。您需要它，因为您想在同一个并发队列中存储具有不同返回类型的任务/函数。 

QueueCall 和 OnExecuteCall 看起来像这样： 

void CAsyncCalculator::QueueCall(boost::function<void()> &call)
{
    m_call_queue.push(call);
    PostThreadMessage(UWM_EXECUTE_CALL, 0, 0);
}
void CAsyncCalculator::OnExecuteCall(WPARAM, LPARAM)
{
    boost::function<void()> call;
    while(m_call_queue.try_pop(call))
    {        
        call();
    }
} 

回调通过类似的劫持过程进行，其中初始回调接口引用被本地存储为成员变量 m_external_callback，并被派生自 ICalculatorEvents 的私有实现所替换。 

一旦回调从 CCalculator 到达 CAsyncCalculator，它就会被打包并排队等待 CEventReceiver 对象执行。 

void CAsyncCalculator::Started(void)
{
    boost::packaged_task<void> task(boost::bind(&ICalculatorEvents::Started, &m_external_callback));
    m_event_receiver.QueueCall(MoveTaskIntoFunction<void>(task));
} 

这在 OnExecuteCall 消息处理方法中发生，与我们在 CAsyncCalculator 中所做的类似。

LRESULT CEventReceiver::OnExecuteCall (WPARAM, LPARAM)
{
    boost::function<void()> call;
    while(m_call_queue.try_pop(call))
    {        
        call();
    }
    return NULL;
}

void CEventReceiver::QueueCall(boost::function<void()> &call)
{
    m_call_queue.push(call);
    ::PostMessage(m_hWnd, UWM_EXECUTE_CALL, 0,0);
}

这可能看起来需要输入很多代码，但我相信肯定有缩短它的方法。