不定义大量的消息宏实现事件与处理关联起来（避免写很多消息宏定义和消息映射）

/*这个宏定义可以写到统一公共的头文件里面，避免值重复了
#define WM_MY_MSG_DISPATCHER1				WM_USER + 1001		//自定义消息分发1，多路分发，防止一个阻塞后后续消息无法处理
#define WM_MY_MSG_DISPATCHER2				WM_USER + 1002		//自定义消息分发2
#define WM_MY_MSG_DISPATCHER3				WM_USER + 1003		//自定义消息分发3
#define WM_MY_MSG_DISPATCHER4				WM_USER + 1004		//自定义消息分发4
*/


/***一个自动锁类，单独一个.h文件即可***/
//CKCritSec.h
//
#ifndef __KCRITSEC_H__
#define __KCRITSEC_H__

#include <windows.h>

#pragma warning(disable:4800)

class CKCritSec
{
public:
	CKCritSec() 
	{
		InitializeCriticalSection(&m_CritSec);
	};

    ~CKCritSec() 
	{
		DeleteCriticalSection(&m_CritSec);         
    };

    void Lock() 
	{
		EnterCriticalSection(&m_CritSec);
    };

    void Unlock() 
	{
		LeaveCriticalSection(&m_CritSec);
    };

protected:
		CRITICAL_SECTION    m_CritSec;
};


class CKAutoLock
{
public:
    CKAutoLock(CKCritSec * plock)
    {
        m_pLock = plock;
		if (m_pLock)
		{
			m_pLock->Lock();
		}
    };

    ~CKAutoLock() {
		if (m_pLock)
		{
			m_pLock->Unlock();
		}
    };

protected:
    CKCritSec * m_pLock;
};


class CKEvent
{
public:
    CKEvent(bool bManualReset = false)
	{
		m_hEvent = CreateEvent(NULL, bManualReset, false, NULL);
	};

    virtual ~CKEvent()
	{
		CloseHandle(m_hEvent);
	};

public:
    bool Set(void) 
	{
		bool    bRet = false;

		bRet = ::SetEvent(m_hEvent);
		return bRet;
	};

    bool Wait(unsigned long ulTimeout)
	{
		if (ulTimeout == 0)
			ulTimeout = 0xffffffff;

		bool    bRet = false;

		if(WAIT_OBJECT_0 == WaitForSingleObject(m_hEvent, ulTimeout))
			bRet = true;
		return bRet;
    };

    bool Reset(void) 
	{ 
		bool    bRet = false;

		bRet = ::ResetEvent(m_hEvent);
		return bRet;
	};

protected:
	HANDLE  m_hEvent;
};
#endif



/****消息分发处理,一个MsgDispatch.h文件即可********/
#pragma once

template<class T>
class CMsgDispatch
{
public:
	CMsgDispatch()
	{
	};
	virtual ~CMsgDispatch() 
	{
		CKAutoLock theLock(&m_lockMsg);
		m_dequeMsg.clear();
	};

	typedef void(T::*POnMsgFunc)(WPARAM wParam, LPARAM lParam);
	typedef struct tagMsg
	{
		tagMsg()
		{
			pFunc = NULL;
			wParam = 0;
			lParam = 0;
		};

		tagMsg& operator=(const tagMsg& value)
		{
			pFunc = value.pFunc;
			wParam = value.wParam;
			lParam = value.lParam;
			return *this;
		};
		POnMsgFunc pFunc;
		WPARAM wParam;
		LPARAM lParam;
	}Msg;

public:
	void OnDispatch()
	{
		Msg theMsg;
		while (GetPostMsg(theMsg))
		{
			POnMsgFunc pFunc = theMsg.pFunc;
			(((T*)this)->*pFunc)(theMsg.wParam, theMsg.lParam);
		}
	};
	void PostMsg(HWND hWnd, POnMsgFunc pMsgFunc, WPARAM wParam = 0, LPARAM lParam = 0)
	{
		AddPostMsg(pMsgFunc, wParam, lParam);

		::PostMessage(hWnd, WM_MY_MSG_DISPATCHER1, 0, 0);
		::PostMessage(hWnd, WM_MY_MSG_DISPATCHER2, 0, 0);
		::PostMessage(hWnd, WM_MY_MSG_DISPATCHER3, 0, 0);
		::PostMessage(hWnd, WM_MY_MSG_DISPATCHER4, 0, 0);
	};
	void AddPostMsg(POnMsgFunc pMsgFunc, WPARAM wParam, LPARAM lParam)
	{
		CKAutoLock theLock(&m_lockMsg);
		Msg theMsg;
		theMsg.pFunc = pMsgFunc;
		theMsg.wParam = wParam;
		theMsg.lParam = lParam;

		m_dequeMsg.push_back(theMsg);
	};
	bool GetPostMsg(Msg& theMsg)
	{
		CKAutoLock theLock(&m_lockMsg);
		if (m_dequeMsg.size() > 0)
		{
			theMsg = m_dequeMsg.front();
			m_dequeMsg.pop_front();
			return true;
		}

		return false;
	}
	CKCritSec m_lockMsg;
	deque<Msg> m_dequeMsg;
};

class CMainWnd : public CWindowWnd, public INotifyUI, public CMsgDispatch<CMainWnd>
{
public:
	CMainWnd();
	~CMainWnd();

	virtual LPCTSTR GetWindowClassName() const { return _T("CMainWnd"); }
	virtual void    Notify(TNotifyUI& msg);
	virtual LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam); 
	virtual LRESULT OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);
	UINT GetClassStyle() const { return CS_DBLCLKS; };	//参考360DEMO

public:
	LRESULT OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam);
	LRESULT OnNcHitTest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);

	void CloseDlg(WPARAM wParam, LPARAM lParam);
	void OnInitHostSuccess(WPARAM wParam, LPARAM lParam);
	void OnInitHostFailed(WPARAM wParam, LPARAM lParam);

protected:
	CPaintManagerUI m_PM;
};

LRESULT CMainWnd::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LRESULT lRes = 0;
	BOOL bHandled = TRUE;

	switch (uMsg)
	{
	case WM_CREATE:						lRes = OnCreate(uMsg, wParam, lParam);							break;
	case WM_NCCALCSIZE:					break;
	case WM_NCACTIVATE:					lRes = 1;														break;
	case WM_NCPAINT:					break;
	case WM_NCHITTEST:					lRes = OnNcHitTest(uMsg, wParam, lParam, bHandled);				break;
	case WM_SIZE:						lRes = OnSize(uMsg, wParam, lParam, bHandled);					break;
	case WM_NCLBUTTONDBLCLK:			bHandled = TRUE;												break;
	case WM_MY_MSG_DISPATCHER1:			OnDispatch();													break;
	case WM_MY_MSG_DISPATCHER2:			OnDispatch();													break;
	case WM_MY_MSG_DISPATCHER3:			OnDispatch();													break;
	case WM_MY_MSG_DISPATCHER4:			OnDispatch();													break;
	default:
		bHandled =FALSE;
	}
	if( bHandled ) return lRes;
	if( m_PM.MessageHandler(uMsg, wParam, lParam, lRes) ) return lRes;
	return CWindowWnd::HandleMessage(uMsg, wParam, lParam);
}

//其他线程函数中
void InitHostThread(ULONG_PTR lParam)
{
    if (true)
	{
		g_pMainWnd->PostMsg(g_pMainWnd->GetHWND(),&CMainWnd::OnInitHostSuccess);
		return;
	}

	g_pMainWnd->PostMsg(g_pMainWnd->GetHWND(), &CMainWnd::OnInitHostFailed);
}