类封装线程函数， 定时器回调函数问题

网上有很多朋友问：
1、如何使类成员函数作为线程入口函数？
2、如何使类的成员函数作为定时器回调函数？
关于这两个问题，网上讨论了很久都没有比较好的解决方法，希望大家踊跃发表自己的看法，尽量解决好此问题。

假设如下模型：
1、自己写好了以个类，并且进行了封装；
2、此类 应该作为一个独立的线程来运行效果比较好；
3、 类中应用到定时器，而我不希望用户知道合适调用定时器函数，即定时器对使用者透明；
4、而我对外提供的初始化接口只有一个CreateInstance()函数，即使用者只需要调用CreateInstance（）函数就可以完成类的初始化，并且调用类的其他成员函数获取此实例的数据状态；
5、对此类应该如何封装？

望大家积极发言！

27 个解决方案

#1

以上问题补充一句：
对涉及线程函数，定时器回调函数时，c++有没有比较好的模型？有没有更好的封装方法？

#2

用静态成员函数。

LZ的语气想是当老师的。

#3

如果用类的成员函数的话，只能用静态成员函数

#4

以前是线程函数和定时器处理函数的原型

#define CALLBACK    __stdcall
#define WINAPI      __stdcall
DWORD WINAPI ThreadProc(
  LPVOID lpParameter   // thread data
);
VOID CALLBACK TimerProc(
  HWND hwnd,         // handle to window
  UINT uMsg,         // WM_TIMER message
  UINT_PTR idEvent,  // timer identifier
  DWORD dwTime       // current system time
);

它们都遵从stdcall的调用约定，而成员函数遵从thiscall的调用约定，
所以没法用类的普通成员函数做为线程和定时器的处理函数。

但可以用static的成员函数。
用static成员函数作为线程处理函数时，一般函数的参数就是对象的指针。

#5

只能用静态函数..
你可以把this指针作为参数传进去.
然后在静态函数中使用指针操作此类的实例

#6

up
第二个问题有人能说下吗..我也不会..
2、如何使类的成员函数作为定时器回调函数？ 

#7

这里第一个问题和第二个问题不是一回事吗？线程入口函数也好，回调函数也好，都不能是非静态成员函数的，因为非静态成员函数中要用到类的成员变量，而这些变量对于不同的对象是有不同的拷贝的，为了跟踪这些变量到底属于哪一个变量，成员函数中隐含有一个参数this，也就是这个指向这个对象的指针，作为回调函数，它的参数类型、个数都是系统定义好的，所以编译都过不去，一定会报参数错

#8

只能用静态函数.. 
你可以把this指针作为参数传进去. 
然后在静态函数中使用指针操作此类的实例
=================
静态函数根本就不带this参数，对于类的静态成员来说，它是所有对象共用的，根本不可能用它来操作类的实例，这也是为什么静态函数中不允许引用非静态成员的原因。非静态成员是每一个实例就有一个自己的拷贝。

#9

以前用过.
定时器的回调函数应该必须是静态函数. 为了解决这个问题也是困扰了我很久.
如果通过实例的指针也许能行.不过没有测试过.

#10

偶不是老师 偶只想搞清楚这些问题，大家回答的都不错。也答到问题的本质了。但问题是如何对此类进行封装呢？
大家有没有好的办法哦！！

#11

引用 5 楼 tg15 的回复:

只能用静态函数.. 
你可以把this指针作为参数传进去. 
然后在静态函数中使用指针操作此类的实例

这个方法貌似比较好哦，即实现了比较好的封装，也解决了线程调用入口函数的问题，我认为可以考虑..

#12

我觉得大家可以参考下面链接 thunk技术 好像很高深的样子 搞不懂，大家讨论一下
http://www.cppblog.com/wangjt/archive/2008/01/31/41939.html

#13

以SetTimer为例，如果要定义一个类成员的回调TimerProc，那么宣称
public:
  ....
  static VOID CALLBACK TimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime);
实现时：
VOID CALLBACK CxxClass::TimerProc(...)
{
   ...
}
我以前在一个项目（activex）里是这样做的实现相关的键盘模拟输出操作。

#14

封装没有固定的方法，主要看具体应用和个人习惯，如果你习惯用MFC，可以从CWinThread派生一个类。

#15

CWinThread派生一个类是一个方法，不过关于定时器回调函数呢？ 可能需要好好考虑一下。

#16

CWinThread中有消息循环，你只要定义一个静态函数，在InitInstance函数中SetTimer最后返回TRUE就可以了。

#17

#include "stdafx.h"
#include "..\RoofKit.h"
#include "MiscKit.h"
#include "MiscX.h"

typedef BOOL (CALLBACK *SPECIFICLOCALTIMETOSYSTEMTIME)(LPTIME_ZONE_INFORMATION
													   ,LPSYSTEMTIME,LPSYSTEMTIME);

typedef BOOL (CALLBACK *SYSTEMTIMETOSPECIFICLOCALTIME)(LPTIME_ZONE_INFORMATION
													   ,LPSYSTEMTIME,LPSYSTEMTIME);

DWORD	__stdcall	AutoShutdownProc(LPVOID	lpParam)
{
	AUTOSHUTDOWNTHREAD	*tgAuto = (PAUTOSHUTDOWNTHREAD)lpParam;
	DWORD	dwRetValue = 0,dwIndex = 0;
	DWORD	dwFlags = tgAuto->dwFlags,dwReason = tgAuto->dwReason;
	HANDLE	hEvent[2] = { 0 };
	hEvent[0] = tgAuto->hTimer;
	hEvent[1] = tgAuto->hExit;
	do
	{
		dwRetValue	=	WaitForMultipleObjects(2,hEvent,FALSE,INFINITE);
		switch(dwRetValue)
		{
		case WAIT_FAILED:
			dwRetValue = GetLastError();
			SetEvent(tgAuto->hExit);
			return dwRetValue;
		case WAIT_OBJECT_0 + 0:
			if(!ExitWindowsEx(dwFlags,dwReason))
			{
				SetEvent(tgAuto->hExit);
				return	GetLastError();
			}
			CloseHandle(tgAuto->hThread);
			CloseHandle(tgAuto->hTimer);
			CloseHandle(tgAuto->hExit);
			free(tgAuto);
			return 0;
		case WAIT_OBJECT_0 + 1:
			SetEvent(tgAuto->hExitCmp);
			return 0;
		}
	}while(TRUE);
	return -1;
}
DWORD	__stdcall	AutoShutdown(HMISCINST *hHandle,HANDLE hProcess,DWORD dwFlags,DWORD dwReason,PSYSTEMTIME lpSt)
{
	PMISCHANDLE	lpInst = NULL;
	PAUTOSHUTDOWNTHREAD	tgAuto = NULL;
	FILETIME ft = { 0 };
	LARGE_INTEGER	tgInt = { 0 };
	tgAuto = (PAUTOSHUTDOWNTHREAD)malloc(sizeof(AUTOSHUTDOWNTHREAD));
	if(!tgAuto)	return ERROR_BAD_ALLOC;
	//
	SystemTimeToFileTime(lpSt,&ft);
	tgInt.HighPart	=	ft.dwHighDateTime; 
	tgInt.LowPart	=	ft.dwLowDateTime;
	tgAuto->hTimer		=	CreateWaitableTimer(NULL,FALSE,NULL);
	tgAuto->hExit		=	CreateEvent(NULL,FALSE,FALSE,NULL);
	tgAuto->hExitCmp	=	CreateEvent(NULL,FALSE,FALSE,NULL);
	if(!SetWaitableTimer(tgAuto->hTimer,&tgInt,0,NULL,NULL,FALSE))
	{
		CloseHandle(tgAuto->hTimer);
		free(tgAuto);
		return GetLastError();
	}
	tgAuto->hThread = CreateThread(NULL,0,AutoShutdownProc,tgAuto,CREATE_SUSPENDED,NULL);
	ResumeThread(tgAuto->hThread);
	lpInst				=	(PMISCHANDLE)malloc(sizeof(MISCHANDLE));
	tgAuto->dwFlags		=	dwFlags;
	tgAuto->dwReason	=	dwReason;
	lpInst->lpVoid		=	(void*)tgAuto;
	lpInst->dwType		=	AUTO_SHUTDOWN;
	*hHandle = (HMISCINST)lpInst;
	return 0;
}
DWORD	__stdcall	AdjustPrivilege(HANDLE hProcess,LPCTSTR lpSeName,LPCTSTR lpSysName
									,DWORD dwAttributs)
{
	HANDLE	hToken = NULL;
	TOKEN_PRIVILEGES NewState = { 0 };
	NewState.PrivilegeCount = 1;
	NewState.Privileges[0].Attributes = dwAttributs;

	if(!OpenProcessToken(hProcess,TOKEN_ALL_ACCESS,&hToken))
		return GetLastError();
	__try
	{
		if(!LookupPrivilegeValue(lpSysName,lpSeName,&NewState.Privileges[0].Luid))
			return GetLastError();	
		if(!AdjustTokenPrivileges(hToken,FALSE,&NewState,0,NULL,0))
			return GetLastError();
	}
	__finally
	{
		if(hToken)	CloseHandle(hToken);
	}
	return 0;
}

DWORD	__stdcall	ReleaseAutoShutdown(PAUTOSHUTDOWNTHREAD	pAuto)
{
	DWORD	dwRetValue = 0,dwMax = 3;
	do
	{
		GetExitCodeThread(pAuto->hThread,&dwRetValue);
		if(dwRetValue == STILL_ACTIVE)
		{
			SetEvent(pAuto->hExit);
			dwRetValue = WaitForSingleObject(pAuto->hExitCmp,1000);
			switch(dwRetValue)
			{
			case WAIT_FAILED:
				CloseHandle(pAuto->hExit);
				CloseHandle(pAuto->hExitCmp);
				CloseHandle(pAuto->hThread);
				CloseHandle(pAuto->hTimer);
				return WAIT_FAILED;
			case WAIT_TIMEOUT:
				dwMax--;
				continue;
				break;
			default:
				CloseHandle(pAuto->hExit);
				CloseHandle(pAuto->hExitCmp);
				CloseHandle(pAuto->hThread);
				CloseHandle(pAuto->hTimer);
				return 0;
			}
		}
	}while(dwMax);
	CloseHandle(pAuto->hExit);
	CloseHandle(pAuto->hExitCmp);
	CloseHandle(pAuto->hThread);
	CloseHandle(pAuto->hTimer);
	return WAIT_FAILED;
}
DWORD	__stdcall	CloseMisc(HMISCINST	hHandle)
{
	PMISCHANDLE	lpInst = (PMISCHANDLE)hHandle;
	DWORD	dwRetValue = 0,dwMax = 3;
	switch(lpInst->dwType)
	{
	case AUTO_SHUTDOWN:
		{
			PAUTOSHUTDOWNTHREAD	tgAuto = (PAUTOSHUTDOWNTHREAD)lpInst->lpVoid;
			dwRetValue = ReleaseAutoShutdown(tgAuto);
			free(lpInst->lpVoid);
			free(lpInst);
			return dwRetValue;
		}
		break;
	default:
		return -1;
	}
	return 0;
}
DWORD	__stdcall	SpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION lpTimeZoneInformation,LPSYSTEMTIME lpLocalTime
												,LPSYSTEMTIME lpUniversalTime)
{
	HMODULE	hModule = GetModuleHandle("Kernel32");
	BOOL	bRetValue = 0;
	SPECIFICLOCALTIMETOSYSTEMTIME	lpProc = NULL;
	lpProc = (SPECIFICLOCALTIMETOSYSTEMTIME)GetProcAddress(hModule
			 ,"TzSpecificLocalTimeToSystemTime");
	if(lpProc == NULL)	return	GetLastError();
	bRetValue = lpProc(lpTimeZoneInformation,lpLocalTime,lpUniversalTime);
	return bRetValue == 0?GetLastError():0;
}
DWORD	__stdcall	SystemTimeToSpecificLocalTime(LPTIME_ZONE_INFORMATION lpTimeZone,LPSYSTEMTIME lpUniversalTime
												 ,LPSYSTEMTIME lpLocalTime)
{
	HMODULE	hModule = GetModuleHandle("Kernel32");
	BOOL	bRetValue = 0;
	SYSTEMTIMETOSPECIFICLOCALTIME	lpProc = NULL;
	lpProc = (SPECIFICLOCALTIMETOSYSTEMTIME)GetProcAddress(hModule
			 ,"SystemTimeToTzSpecificLocalTime");
	if(lpProc == NULL)	return	GetLastError();
	bRetValue = lpProc(lpTimeZone,lpLocalTime,lpUniversalTime);
	return bRetValue == 0?GetLastError():0;
}

#18

#ifdef MISCKIT_EXPORTS
#define MISCKIT_API __declspec(dllexport)
#else
#define MISCKIT_API __declspec(dllimport)
#endif

#include "..\RoofKit.h"
#include "MiscX.h"

#if defined(__cplusplus)
extern "C"
{
#endif

	MISCKIT_API	DWORD	__stdcall	AutoShutdown(HMISCINST *hHandle,HANDLE hProcess,DWORD dwFlags,DWORD dwReason,PSYSTEMTIME lpSt);

	MISCKIT_API	DWORD	__stdcall	CloseMisc(HMISCINST	hHandle);

	MISCKIT_API	DWORD	__stdcall	AdjustPrivilege(HANDLE hProcess,LPCTSTR lpSeName,LPCTSTR lpSysName
													,DWORD dwAttributs);
	MISCKIT_API	DWORD	__stdcall	SpecificLocalTimeToSystemTime(LPTIME_ZONE_INFORMATION lpTimeZoneInformation,LPSYSTEMTIME lpLocalTime
																,LPSYSTEMTIME lpUniversalTime);
	MISCKIT_API	DWORD	__stdcall	SystemTimeToSpecificLocalTime(LPTIME_ZONE_INFORMATION lpTimeZone,LPSYSTEMTIME lpUniversalTime
																,LPSYSTEMTIME lpLocalTime);

#if defined(__cplusplus)
};
#endif	//extern "C"

#19

不知道你要干吗但如果只是件简单的实现定时功能而不想关联UI的话可以使用定时器内核事件实现。
至于回调只是在句柄结构内加一个函数指针再多几个参数变量

#define AUTO_SHUTDOWN		0x0000C000	//

#define SE_PRIVILEGE_ALL	0x0000A000	//
//SDK版本比较低则补充定义2000以后规定权限
#if (_WIN32_WINNT < 0x0600)
	#define SE_UNDOCK_NAME                    TEXT("SeUndockPrivilege")
	#define SE_SYNC_AGENT_NAME                TEXT("SeSyncAgentPrivilege")
	#define SE_ENABLE_DELEGATION_NAME         TEXT("SeEnableDelegationPrivilege")
	#define SE_MANAGE_VOLUME_NAME             TEXT("SeManageVolumePrivilege")
	#define SE_IMPERSONATE_NAME               TEXT("SeImpersonatePrivilege")
	#define SE_CREATE_GLOBAL_NAME             TEXT("SeCreateGlobalPrivilege")
#endif

typedef struct _tgAutoShutdownThread
{
	HANDLE	hThread;
	HANDLE	hTimer;
	HANDLE	hExit;
	HANDLE	hExitCmp;
	DWORD	dwFlags;
	DWORD	dwReason;
}AUTOSHUTDOWNTHREAD,*PAUTOSHUTDOWNTHREAD;

typedef struct _tgMiscHandle
{
	DWORD	dwType;
	void	*lpVoid;
}MISCHANDLE,*PMISCHANDLE;

#20

学习 学习！！

#21

请参考http://blog.csdn.net/ringphone/archive/2004/10/18/141074.aspx

 线程的封装技巧：把任意类的成员函数指针作为参数收藏

线程的封装很简单，并没有多少东西，但是如果我告诉你，我封装的这个线程类里有个成员函数Start，作用是开启线程运行，可以这样调用：

class a
{
public:
 DWORD ThreadFunca(LONG lParam);
 void StartThread();
 CMyThread m_thread;
}

DWORD a::ThreadFunca(LONG lParam)
{
 //线程执行代码 ...
}

class b
{
public:
 DWORD ThreadFuncb(LONG lParam);
 void StartThread();
 CMyThread m_thread;
}

DWORD b::ThreadFuncb(LONG lParam)
{
 //线程执行代码 ...
}

//调用代码：
void a::StartThread()
{
   m_thread.Start(this,(THREADFUNC)ThreadFunca);
}

void b::StartThread()
{
   m_thread.Start(this,(THREADFUNC)ThreadFuncb);
}

    你是不是会觉得很神奇呢？a和b是完全不相干的两个类，但其成员函数却能作为参数传进去。这个Start并不是宏，那其参数是怎么定义的呢？

    聪明的你一定已经想到模板了，不错，这个Start是一个模板函数，但是调用时却见不到模板调用时常见的xxx<yyy>格式，并且调用的类，这个线程类产生对象时也不需要把具体数据类型传入，这里用到了一点技巧。

    首先，想象一下这个Start的实现机制，按线程实现的规则，一定是先把线程函数定位到一个全局或静态的线程处理函数，然后由这个函数转到具体的成员处理函数。这样，这个函数就必须知道类a或b的成员函数指针，加上原来线程需要传入的参数，因此传入这个全局线程处理函数的参数就必须是一个结构了。定义一下这个结构：
template <typename T>
struct ThreadInfo
{
 typedef DWORD (T::*THREADFUNC1)(LONG);
 T* m_obj;
 LONG m_param;
 THREADFUNC1 m_lpthreadFunc; 
};

这个结构应该是作为CMyThread的成员数据，由CMyThread创建线程的时候作为参数传给线程处理函数，对用户是透明的。这时候问题来了，创建CMyThread对象的时候必须初始化这个结构，但这时候还没调用Start，并不知道具体调用类的类型，而这个结构是必须关联到具体数据类型的，CMyThread初始化的时候这个结构该是什么类型呢？这里就要用到一个数据类型强制转换的技巧了，我们先声明一个空的类，拿这个类初始化这个结构：

class NULLCLASS
{
};

为了方便，typedef一下：typedef ThreadInfo<NULLCLASS> ThInfo;
这个结构的类型就是：

class CMyThread
{
   ...
private:
   ThInfo* m_info;
};

这里额外提一下，在Borland C++ 5.02下，这个NULLCLASS只需要声明，不需要实现，即可以不加{}：class NULLCLASS;就行了，但是VC6就不行，加不加{}，其sizeof(NULLCLASS)返回的尺寸是不一样的，加了{}返回的尺寸才是对的，不知是哪个公司错了。

发现没有，这个m_info结构里有了一个DWORD NULLCLASS::THREADFUNC1)(LONG);函数指针，而这个NULLCLASS根本没有这个函数，没关系，这个NULLCLASS只是用来做数据类型转换用，顺带也转换了成员函数指针类型。为了方便，再typedef一下这个成员函数指针：typedef ThreadInfo<NULLCLASS>::THREADFUNC1 THREADFUNC;
这样这个Start就能实现了：

class CMyThread
{
public:
 CMyThread();
 ~CMyThread();

 template<typename tname>
 BOOL Start(tname* obj,THREADFUNC func,LONG param = 0)
 {  
  if(m_handle || obj == NULL || func == NULL)
   return FALSE; //已有线程运行

  ThreadInfo<tname>* lpv = new ThreadInfo<tname>;
  lpv->m_obj = obj;
  lpv->m_param = param;
  lpv->m_lpthreadFunc = (ThreadInfo<tname>::THREADFUNC1)func;
  
  m_info = (ThInfo*)lpv;
   DWORD gdwThreadId = 0;
  m_handle = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)ThreadProc,m_info,0,&gdwThreadId);
  return (BOOL)m_handle;
 }
 ...

private:
 static DWORD WINAPI ThreadProc(ThInfo* obj);

private:
 HANDLE m_handle;
 ThInfo* m_info;
};

ThreadProc就很简单了：

DWORD WINAPI CMyThread::ThreadProc(ThInfo* obj)
{
 if(obj)
  return (obj->m_obj->*(obj->m_lpthreadFunc))(obj->m_param);
 return 0;
}

这样就可以象上面的代码那样调用：m_thread.Start(this,(THREADFUNC)ThreadFunca);了，利用typename，把this指针传递进去，会自动判别数据类型，再利用NULLCLASS作为数据类型转换过个桥，这样就实现任意类的成员函数指针传递了。而传统的解决方法就需要在调用时多实现一个全局线程函数，传递this指针进去，再在全局线程函数中得到这个指针调用成员函数，并没实现真正的封装。

#22

引用 5 楼 tg15 的回复:

只能用静态函数.. 
你可以把this指针作为参数传进去. 
然后在静态函数中使用指针操作此类的实例

静态函数是可以，但是this指针无法传递进去，在调用的时候提示错误：参数无法转换。代码如下：

// 创建线程代码
::CreateThread(NULL, 0, CMainMng::MainMngProc, 0, 0, 0);

// 线程入口 静态函数
class CMainMng : public CObject  
{
public:
	CMainMng();
	virtual ~CMainMng();
	static DWORD WINAPI MainMngProc(LPVOID lpParameter, CMainMng* thisMng){return 0;};

public:
	int m_nTes;
};

#23

线程函数只有一个参数，你的CMainMng::MainMngProc函数有两个参数，是不行的。

#24

哦，晓得。

#25

用静态成员函数吧...
记得将this指针传进去...
(LPVOID)this...

#26

路过，学些了，

#27

如何将定时器的回调函数作为类的成员函数？

我认为这两个问题不完全是同一回事，首先类的静态方法是可以作为回调函数的，但是在静态函数中不能访问类的非静态变量，很不方便。
对于线程的回调函数，可以在createthread的时候将this传进去，这样在静态的回调函数中通过传入的指针可以方便访问类中的成员，这个方法完全可行，我也用过。
但是，对于SetTimer的回调函数就无法做到这点，因为无法在settimer没有提供给传给timerproc的参数。

寻求好方法中。。。