模板应用--UI线程与worker线程同步 模仿c# invoke

由之前的一篇博文 《UI线程与worker线程》《UI线程与worker线程》引出，UI线程与worker线程“串行化”在win32上实现是多么没有节操的事情，代码编写麻烦不说，编写过程中容易打断思路，还不易于维护，遇到这种重复性高的代码（即使操作步骤一样），就像眼里的沙，一刻都容忍不得，必须想出一种办法解决这种现状。

由于之前项目中需要临时用C#写个小工具，用来调试和测试，当中也遇到了类似的问题，其中发现，.net本身就提供了解决这类问题的方法，而且很简单，在worker线程执行处先判断当前Form对象的InvokeRequired属性，如果需要等待UI线程执行完，则创建一个delegate给invoke，妈蛋，MS那帮懒人，MFC就是一直不更新，只能自己动手了。

既然.net提供了这么一个方法可以解决这个问题，那win32程序自然也可以有这么一种方法（当然不是使用.net那种），实在没有的话模仿它，照猫话虎也行。好，动手干吧，实验一下又不会怀孕。在整理出需要关注哪些细节问题之前，先明确一下目的，换句话说，先明确一下到时这个实验结果怎么应用到工程当中。

既然有.net这样样板可供参考，那就按照它那样来，到时client代码应该写起来像这样：

void window_obj::create_and_run_thread(){
boost::thread t1(boost::bind(&window_obj::thread_func1, this));
boost::thread t2(boost::bind(&window_obj::thread_func2, this));
}

void window_obj::thread_func1(){
for (;;){
if (need_exit)
break;
// do something to ask for result
received_result1(result);
}
}

void window_obj::thread_func2(){
for (;;){
if (need_exit)
break;
// do something to ask for result
received_result2(result1, result2);
}
}

void window_obj::received_result1(result_type result1){
// 最好能用把这个条件分支用宏定义代替，要简单直观
if (required){
invoke(window_obj::received_result1, this, result1);
return;
}

// do something with result 1 in UI thread
}

void window_obj::received_result2(result_type result1, other_type result2){
// 然后在把这个条件分支用宏定义代替，要简单直观
if (required){
invoke(window_obj::received_result2, this, result1, result2);
return;
}

// do something with result1 and result2 in UI thread
}

嗯，看起来像回事，接下来看怎么实现了。

1.需要有个可调用的东西用来判断当前是否需要invoke，即当前线程是否与UI线程相同，这最好办了；

2.既然只能通过sendmessage实现，那invoke就是对sendmessage的封装，并且把window_obj::received_result这个member function用boost::function打包一下，通过指针传给sendmessage作为参数叫给UI线程调用；既然是sendmessage，就必须得自定义一个消息，然后在window_obj的消息响应里执行这个worker传过来的functor，好吧，就用RegisterWindowMessage这个API生成Message ID吧；

3.既然要省去添加消息映射宏，那就得消息处理函数认识这个消息id，有两个方案可选消息钩子、修改这个窗口的窗口过程函数入口SetWindowLong，后一种简单一些；把原先的窗口过程函数用变量old_proc_保存起来，以便这个消息id之外的其他消息能正常响应，窗口过程函数又是一个全局函数或静态函数，那old_proc_变量也必须是全局或静态的，且这是在多线程环境，那必须对old_proc_变量值的修改进行加锁；

4.考虑到对窗口调用SetWindowLong时要对old_proc_值的更改进行安全保护而加锁，为了把这种加锁解锁的开销降到最低，又要满足任何窗口类型都能使用这个类，把这个类设计成模板类是个不错的选择。

根据以上4点，基本满足了使用需求，先写出代码：

#include <map>
#include <set>
#include <boost/function.hpp>
#include <boost/thread.hpp>

namespace invoke
{
/*
** to check if the calling thread is different from UI thread
*/
static bool		required(){
return ::GetCurrentThreadId() != AfxGetApp()->m_nThreadID;
}

//////////////////////////////////////////////////////////////////////////

typedef boost::function<void (void)>	operate_func;

//////////////////////////////////////////////////////////////////////////

template<class T>
class dispatch
{
static boost::mutex		mtx_;
static WNDPROC			old_proc_;
public:
static UINT			msg_id_;

protected:

dispatch(){}

static UINT	wnd_proc(HWND hWnd, UINT msg, WPARAM w, LPARAM l)
{
if (msg == msg_id_){
// call the message function
(*(invoke::operate_func*)l)();
return 1;
}

return ::CallWindowProc(old_proc_, hWnd, msg, w, l);
}

public:

static void request_invoke(HWND hWnd)
{
if (!old_proc_){
// maybe other thread is update the old_proc_ value
boost::unique_lock<boost::mutex> guard(mtx_);
if (!old_proc_)
// i am sure that the old_proc_ update operation won't conflict
old_proc_ = (WNDPROC)::SetWindowLong(hWnd, GWL_WNDPROC, (LONG)&wnd_proc);
}
}
};

template<class T>
boost::mutex dispatch<T>::mtx_;

template<class T>
WNDPROC dispatch<T>::old_proc_ = NULL;

template<class T>
UINT dispatch<T>::msg_id_ = ::RegisterWindowMessage(_T("INVOKE_MSG_DEFINE"));
}

然后使用的时候像这样：
void window_obj::received_result1(result_type result1){
// 最好能用把这个条件分支用宏定义代替，要简单直观
if (this == NULL || !::IsWindow(GetSafeHwnd()))
return;
if (invoke::required()){
invoke::dispatch<cls>::request_invoke(GetSafeHwnd());
UINT msg = invoke::dispatch<cls>::msg_id_;
invoke::operate_func f = boost::bind(&cls::func, this, result1);
::SendMessage(GetSafeHwnd(), msg, (WPARAM)0, (LPARAM)&f);
return;
}

// do something with result 1 in UI thread
}

如果函数中有多个参数需要传递给UI线程，那也只需把要传递的参数在boost::bind(&cls::func, this, result1);末尾添加进去打包成boost::function就行了，那剩下的就是把它写成宏定义，使用的时候方便。
#define NEED_INVOKE_BEGIN(cls, func)	\
if (this == NULL || !::IsWindow(GetSafeHwnd()))	\
return;	\
if (invoke::required()){	\
invoke::dispatch<cls>::request_invoke(GetSafeHwnd());	\
UINT msg = invoke::dispatch<cls>::msg_id_;	\
invoke::operate_func f = boost::bind(&cls::func, this

#define NEED_INVOKE_END	\
);	\
::SendMessage(GetSafeHwnd(), msg, (WPARAM)0, (LPARAM)&f);	\
return;	\
}

#define NEED_INVOKE0(cls, func)	\
NEED_INVOKE_BEGIN(cls, func)	\
NEED_INVOKE_END

#define NEED_INVOKE1(cls, func, a1)	\
NEED_INVOKE_BEGIN(cls, func)	\
, boost::ref(a1)	\
NEED_INVOKE_END

#define NEED_INVOKE2(cls, func, a1, a2)	\
NEED_INVOKE_BEGIN(cls, func)	\
, boost::ref(a1)	\
, boost::ref(a2)	\
NEED_INVOKE_END

#define NEED_INVOKE3(cls, func, a1, a2, a3)	\
NEED_INVOKE_BEGIN(cls, func)	\
, boost::ref(a1)	\
, boost::ref(a2)	\
, boost::ref(a3)	\
NEED_INVOKE_END

然后像这样使用

void window_obj::received_result1(result_type result1){
NEED_INVOKE2(window_obj, received_result1, result1)；

// do something with result 1 in UI thread
}

若要支持更多的参数个数，照猫画虎写多几个宏定义即可，不过通常一个函数要是函数参数过多，我也会抓狂。。。