1. Introduction
当我们在用 MFC 编程的时候,我们经常用到 AfxGetApp() 来获得当前的 CWinApp 的 Instance 。看看 MFC 的源代码中 AfxGetApp() 的实现,你会发现 AfxGetApp() 的实现并不像一般情况下面那样直接:
_AFXWIN_INLINE CWinApp* AFXAPI AfxGetApp() { return afxCurrentWinApp; } #define afxCurrentWinApp AfxGetModuleState()->m_pCurrentWinApp |
AfxGetApp() 调用的是 AfxGetModuleState() ,该函数返回一个 AFX_MODULE_STATE 的指针,其中的一个成员保存着当前的 CWinApp 的指针。可 AfxGetModuleState() 的作用又是什么呢?
此外,当我们在开发 MFC DLL 程序的时候,我们会在每个输出的 DLL 函数前面加上一句 AFX_MANAGE_STATE :
void SomeMFCDllFunction() { AFX_MANAGE_STATE(AfxGetStaticModuleState()) … |
AFX_MANAGE_STATE 又是起什么作用呢?从字面上看来,它是 Manage 某种 State ,而 AfxGetStaticModuleState 又是获得 State 的,那么 State 究竟是什么呢?
在 MFC 中, States 用来保存某种相关的状态信息,分为下面几类:
1. Process State ,和某个单独的进程绑定起来
2. Thread State , 和某个单独的线程绑定
3. Module State , 和 Module 相关
前两种 State 和一般的全局变量十分类似,只是根据需求的不同被绑定于不同的进程 / 线程,如多线程支持 等。而 Module State 本身比较特别, Module State 根据情况的不同,可以是全局,线程,或者进程相关的 State ,并且可以根 据要求快速切换。
2. Process State
常见的 Process State 有:
1. _AFX_WIN_STATE
2. _AFX_DB_STATE
3. _AFX_DEBUG_STATE
4. _AFX_SOCK_STATE
5. ……
从字面上面可以很容易猜出这些状态的用处。
MFC 通过下面的宏来定义 Process State:
#define PROCESS_LOCAL(class_name, ident_name) / AFX_COMDAT CProcessLocal<class_name> ident_name; #define EXTERN_PROCESS_LOCAL(class_name, ident_name) / extern CProcessLocal<class_name> ident_name; |
PROCESS_LOCAL 用 CProcessLocal 模板类定义了一个 CProcessLocal<class_name> 的一个实例作为状态变量,而 EXTERN_PROCESS_LOCAL 则使在头文件中声明此状态变量。 CProcessLocal 的定义如下:
class AFX_NOVTABLE CProcessLocalObject { public: // Attributes CNoTrackObject* GetData(CNoTrackObject* (AFXAPI* pfnCreateObject)());
// Implementation CNoTrackObject* volatile m_pObject; ~CProcessLocalObject(); };
template<class TYPE> class CProcessLocal : public CProcessLocalObject { // Attributes public: AFX_INLINE TYPE* GetData() { TYPE* pData = (TYPE*)CProcessLocalObject::GetData(&CreateObject); ENSURE(pData != NULL); return pData; } AFX_INLINE TYPE* GetDataNA() { return (TYPE*)m_pObject; } AFX_INLINE operator TYPE*() { return GetData(); } AFX_INLINE TYPE* operator->() { return GetData(); }
// Implementation public: static CNoTrackObject* AFXAPI CreateObject() { return new TYPE; } };
|
CProcessLocal 的作用只是一个 Wrapper , Hold 一个 TYPE* 的指针,一旦用户调用 GetData 来获得这个指针, GetData 会首先判断该指针是否为空,如果为空,则创建一个新的实例保存起来,否 则返回已有的指针。前提条件是, TYPE 必须从 CNoTrackObject 继承。任何从 CNoTrackObject 继承的类都拥有自己的 new/delete ,这样此对象便不会被 Debug 的内存分配系统所跟踪而误判为 Leak 。
CNoTrackObject* CProcessLocalObject::GetData( CNoTrackObject* (AFXAPI* pfnCreateObject)()) { if (m_pObject == NULL) { AfxLockGlobals(CRIT_PROCESSLOCAL); TRY { if (m_pObject == NULL) m_pObject = (*pfnCreateObject)(); } CATCH_ALL(e) { AfxUnlockGlobals(CRIT_PROCESSLOCAL); THROW_LAST(); } END_CATCH_ALL AfxUnlockGlobals(CRIT_PROCESSLOCAL); } return m_pObject; } |
3. Thread State
和 Process State 类似, Thread State 和 某个线程绑定起来, Thread State 有:
1. _AFX_THREAD_STATE
2. _AFXCTL_AMBIENT_CACHE
同样的, Thread State 是 被 THREAD_LOCAL 和 EXTERN_THREAD_LOCAL 定义,也有 CThreadLocal 和 CThreadLocalObject 来 Hold 住 Thread State 的指针。 CThreadLocal 和 CProcessLocal 的实现方式不太一样, CThreadLocal 利用 TLS(Thread Local Storage) 来保存指针, 而不是用成员变量。简单来说, Thread Local Storage 是 Windows 支持的功能,可以在任意线程中保存多个 DWORD 数据,每个这样 的 DWORD 数据所占的位置称之为 Slot ,分配数据需要分配一个 Slot ,获得和修改数据 CThreadLocalObject::GetData 的实现如下:
CNoTrackObject* CThreadLocalObject::GetData( CNoTrackObject* (AFXAPI* pfnCreateObject)()) { ENSURE(pfnCreateObject);
if (m_nSlot == 0) { if (_afxThreadData == NULL) { _afxThreadData = new(__afxThreadData) CThreadSlotData; ENSURE(_afxThreadData != NULL); } m_nSlot = _afxThreadData->AllocSlot(); ENSURE(m_nSlot != 0); } CNoTrackObject* pValue = static_cast<CNoTrackObject*>(_afxThreadData->GetThreadValue(m_nSlot)); if (pValue == NULL) { // allocate zero-init object pValue = (*pfnCreateObject)();
// set tls data to newly created object _afxThreadData->SetValue(m_nSlot, pValue); ASSERT(_afxThreadData->GetThreadValue(m_nSlot) == pValue); } return pValue; } |
CThreadLocalObject::GetData 首先判断 m_nSlot ,如果 m_nSlot == 0 ,说明该 Thread State 未 曾分配, GetData 函数将会使用 _afxThreadData->AllocSlot 函数分配一个新的 TLS 的 Slot ,保存在 m_nSlot 之中,然后调用 GetThreadValue 检查 pValue 是否为 NULL ,如果是,则创建一个新的对象然后调用 SetValue 把 pValue 设置到该 Slot 之中。 _afxThreadData 的类型为 CThreadSlotData ,是对 TLS API 的一个简单的封装。
_AFX_THREAD_STATE 是一个很常用的 Thread State ,每个 Thread ,都会有自 己的一份 _AFX_THREAD_STATE 。 MFC 提供了一个函数 AfxGetThreadState 来获得当前进程的 Thread State ,如果当前的线程还没有 Thread State , 该函数会创建一个新的 Thread State 。
_AFX_THREAD_STATE* AFXAPI AfxGetThreadState() { _AFX_THREAD_STATE *pState =_afxThreadState.GetData(); ENSURE(pState != NULL); return pState; } |
_AFX_THREAD_STATE 中保存着下列信息:
1. 当前的 m_pModuleState ,每个线程都知道它当前的 Module State ,这个信息被用来获得当前的 Module State , AfxGetModuleState 正是这么做的:
AFX_MODULE_STATE* AFXAPI AfxGetModuleState() { _AFX_THREAD_STATE* pState = _afxThreadState; ENSURE(pState); AFX_MODULE_STATE* pResult; if (pState->m_pModuleState != NULL) { // thread state's module state serves as override pResult = pState->m_pModuleState; } else { // otherwise, use global app state pResult = _afxBaseModuleState.GetData(); } ENSURE(pResult != NULL); return pResult; } |
2. 之前的 m_pModuleState ,用来保存之前的 Module State ,用于 Module State 切 换,可参考 AFX_MANAGE_STATE
3. 其他信息,具体可以参考 _AFX_THREAD_STATE 的定义
4. Module State
Module State 保存着和 Module 相关的状态 信息。 Module 是 Windows 的术语,代表任何一个可执行的代码文件, EXE 和 DLL 都是 Module 的一种。 Module State 有 下面几种:
1. AFX_MODULE_STATE ,保存 MODULE 的信息,是 _AFX_BASE_MODULE_STATE 和 _AFX_DLL_MODULE_STATE 的基类
2. _AFX_BASE_MODULE_STATE ,保存 MFC Module 的状态信息,没有定义其他的成员
3. _AFX_DLL_MODULE_STATE ,保存 DLL 的状态信息,没有定义其他的成员
4. AFX_MODULE_THREAD_STATE ,保存主线程的有关状态信息,虽然 AFX_MODULE_THREAD_STATE 是保存的线程的状态信息,但是它只保存 Module 的主线程的状 态信息,所以可以看作是 Module State 的一种。
这些 Module State 保存了 MFC 中的大量重要信息:
1. CWinApp 指针
2. 实例句柄
3. 资源 Module 的句柄
4. 句柄表
5. OLE 相关信息
6. 窗口过程
7. Activation Context
8. ……
4.1 AFX_MODULE_STATE
AFX_MODULE_STATE 的定义如下:
// AFX_MODULE_STATE (global data for a module) class AFX_MODULE_STATE : public CNoTrackObject { public: #ifdef _AFXDLL AFX_MODULE_STATE(BOOL bDLL, WNDPROC pfnAfxWndProc, DWORD dwVersion, BOOL bSystem = FALSE); #else explicit AFX_MODULE_STATE(BOOL bDLL); #endif ~AFX_MODULE_STATE();
CWinApp* m_pCurrentWinApp; HINSTANCE m_hCurrentInstanceHandle; HINSTANCE m_hCurrentResourceHandle; LPCTSTR m_lpszCurrentAppName; // …… 其他成员,从略 }; |
可以看到:
1. AFX_MODULE_STATE 从 CNoTrackObject 继承。 CNoTrackObject 定义了自己的 new/delete 保证自己不会被各种调试版本的 new/delete 来 Track ,以免自己被 错误的当作 Leak 。
2. AFX_MODULE_STATE 在 DLL 和非 DLL (也就是 EXE )的情况下具有不同的构造函数(和成员)
3. AFX_MODULE_STATE 在成员中保存了一些和 Module 相关的重要信息
实际上, AFX_MODULE_STATE 并没有被直接使用,而是作为 _AFX_BASE_MODULE_STATE 和 _AFX_DLL_MODULE_STATE 的基类:
_AFX_BASE_MODULE_STATE 被用于 Module ,其定义如下:
class _AFX_BASE_MODULE_STATE : public AFX_MODULE_STATE { public: #ifdef _AFXDLL _AFX_BASE_MODULE_STATE() : AFX_MODULE_STATE(TRUE, AfxWndProcBase, _MFC_VER) #else _AFX_BASE_MODULE_STATE() : AFX_MODULE_STATE(TRUE) #endif { } };
PROCESS_LOCAL(_AFX_BASE_MODULE_STATE, _afxBaseModuleState) |
_AFX_DLL_MODULE_STATE 和 _AFX_BASE_MODULE_STATE 类似,只是仅用于 DLL :
class _AFX_DLL_MODULE_STATE : public AFX_MODULE_STATE { public: _AFX_DLL_MODULE_STATE() : AFX_MODULE_STATE(TRUE, AfxWndProcDllStatic, _MFC_VER) { } };
static _AFX_DLL_MODULE_STATE afxModuleState; |
这两个 class 都没有定义额外的成员,比较简单,只是传入到基类 AFX_MODULE_STATE 的参数不同。此外,他们定义的方式不太一样,前者使用的是 PROCESS_LOCAL 宏,定义了一个变量 _afxBaseModuleState 。后者只是简单的定义了一个 static 变量 afxModuleState 。
下面这些函数可以用来获得 Module 的 State :
1. AfxGetModuleState
AfxGetModuleState 首先获得 _afxThreadState 的 m_pModuleState ,如果当前的 Thread State 的 m_pModuleState 返回 NULL ,说明当前的 Thread State 没有正确的初始化(通常的原因是 创建线程的时候调用的是 CreateThread 函数而非 AfxBeginThread ),则使用 _afxBaseModuleState 。
AFX_MODULE_STATE* AFXAPI AfxGetModuleState() { _AFX_THREAD_STATE* pState = _afxThreadState; ENSURE(pState); AFX_MODULE_STATE* pResult; if (pState->m_pModuleState != NULL) { // thread state's module state serves as override pResult = pState->m_pModuleState; } else { // otherwise, use global app state pResult = _afxBaseModuleState.GetData(); } ENSURE(pResult != NULL); return pResult; } |
_afxBaseModuleState 是用 PROCESS_LOCAL 定义的:
PROCESS_LOCAL(_AFX_BASE_MODULE_STATE, _afxBaseModuleState) |
它代表整个 MFC Module 的 State 。当你的程序 是动态链接到 MFC DLL 的时候,该 State 只有一份。如果你的程序是静态链接到 MFC 的话,有几个模块( EXE/DLL )静态链 接到 MFC , MFC 的代码就有几份,那么 _afxBaseModuleState 也就有几份。
2. AfxGetStaticModuleState
AfxGetStaticModuleState 在不同的 Project 下面有着不同的行为:在 DLL 项目中, AfxGetSaticModuleState 返回 afxModuleState ,也就是定义好的 _AFX_DLL_MODULE_STATE ,而在非 DLL 项目中, AfxGetStaticModuleState 直接调用 AfxGetModuleState 。可以看到,在 DLL 的情况下,必须使用 AfxGetStaticModuleState 才可以获得 DLL 本身的 Module State 。
#ifdef _AFXDLL
static _AFX_DLL_MODULE_STATE afxModuleState;
AFX_MODULE_STATE* AFXAPI AfxGetStaticModuleState() { AFX_MODULE_STATE* pModuleState = &afxModuleState; return pModuleState; }
#else
AFX_MODULE_STATE* AFXAPI AfxGetStaticModuleState() { AFX_MODULE_STATE* pModuleState = AfxGetModuleState(); return pModuleState; } #endif |
3. AfxGetAppModuleState
AfxGetAppModuleState 是最简单的,直接返回 _afxBaseModuleState :
AFX_MODULE_STATE* AFXAPI AfxGetAppModuleState() { return _afxBaseModuleState.GetData(); } |
从上面的讨论可以看出,当前处于那个 MFC Module 的 状态之中,返回的就是那个 MFC Module 所相关联的 CWinApp 对象。如果你有多个 Module 都是动态链接到 MFC DLL 的话,那么 AfxGetAppModuleState 返回的总是同一个 CWinApp 。
5. AFX_MANAGE_STATE
AFX_MANAGE_STATE 的作用切换到指定的 Module State ,当出了作用域的时候将 Module State 恢 复到原来的值。是在不同的 Module State 之中切换,原因有 2 :
1. 在不同的 MFC DLL 和 MFC EXE 的 Module State 之间切换,保持正确的 AFX_MODULE_STATE ,最常见的问题是在 DLL 输出的函数之中无法获得 DLL 本身相关的资源,这就是没有正确维护 Module State 的 原因造成的,因为当前 Resource DLL 的句柄就保存在 Module State 之中。
2. 切换 Activation Context ,不同的 Module 必然有着不同的 Activation Context ,需要切换。这是属于 Side By Side 的 内容,以后我会专门写一篇文章来讲述 Side By Side 和 manifest 的相关信息。
一般的用法如下:
void SomeMFCDllFunction() { AFX_MANAGE_STATE(AfxGetStaticModuleState()) … |
注意这里使用的是 AfxGetStaticModuleState ,而非 AfxGetModuleState 。原因是在 DLL 项目中, AfxGetStaticModuleState 返回的是 DLL 本身的 Module State ,而 AfxGetModuleState 则是返回当前线程相关的 Module State ,由于一般 DLL 输出的函数是被其他 Module 调用,那么大部分情况下当前线程的 Module State 都 是错误的,所以必须得使用 DLL 本身的 Module State 。
AFX_MANAGE_STATE 只是一个宏,如下:
struct AFX_MAINTAIN_STATE2 { explicit AFX_MAINTAIN_STATE2(AFX_MODULE_STATE* pModuleState) throw(); ~AFX_MAINTAIN_STATE2();
protected: #ifdef _AFXDLL AFX_MODULE_STATE* m_pPrevModuleState; _AFX_THREAD_STATE* m_pThreadState; #endif
ULONG_PTR m_ulActCtxCookie; BOOL m_bValidActCtxCookie; };
#define AFX_MANAGE_STATE_NO_INIT_MANAGED(p) AFX_MAINTAIN_STATE2 _ctlState(p); #define AFX_MANAGE_STATE(p) _AfxInitManaged(); AFX_MANAGE_STATE_NO_INIT_MANAGED(p) |
可以看到 AFX_MANAGE_STATE 声明了一个栈上的局部变量 _ctrlState ,类型为 AFX_MAINTAIN_STATE2 。这是一个很常用的 Pattern , AFX_MAINTAIN_STATE2 在构造函数的时候会将当前的 Module State 切 换为参数中指定的 Module State :
AFX_MAINTAIN_STATE2::AFX_MAINTAIN_STATE2(AFX_MODULE_STATE* pNewState) throw() { #ifdef _AFXDLL m_pThreadState = _afxThreadState.GetData(); ASSERT(m_pThreadState); if(m_pThreadState) { m_pPrevModuleState = m_pThreadState->m_pModuleState; m_pThreadState->m_pModuleState = pNewState; } else { // This is a very bad state; we have no good way to report the error at this moment // since exceptions from here are not expected m_pPrevModuleState=NULL; m_pThreadState=NULL; } #endif
if (AfxGetAmbientActCtx() && pNewState->m_hActCtx != INVALID_HANDLE_VALUE) { m_bValidActCtxCookie = AfxActivateActCtx(pNewState->m_hActCtx, &m_ulActCtxCookie); } else { m_bValidActCtxCookie = FALSE; } } |
然后在析构函数的时候将其恢复回来:
// AFX_MAINTAIN_STATE2 functions _AFXWIN_INLINE AFX_MAINTAIN_STATE2::~AFX_MAINTAIN_STATE2() { #ifdef _AFXDLL // Not a good place to report errors here, so just be safe if(m_pThreadState) { m_pThreadState->m_pModuleState = m_pPrevModuleState; } #endif
if (m_bValidActCtxCookie) { BOOL bRet; bRet = AfxDeactivateActCtx(0, m_ulActCtxCookie); ASSERT(bRet == TRUE); } } |
可以看到, AFX_MAINTAIN_STATE2 将当前 _afxThreadState 在 m_pThreadState 中存起来,然后将所指向的 Module State 保存在 m_pPrevModuleState 中。在析构函数中,则使用保存起来的 m_pPrevModuleState 恢复到 m_pThreadState 的 Module State 。除了保存恢复 Module state 之 外, AFX_MAINTAIN_STATE2 也会在切换 Activation Context 。这个 Activation Context 被用来查找 Side By Side Assemblies ,我以后会专门写一篇文章讲述 Side By Side 和 Manifest 相关的 一些信息。这次就写到这里。