定时器线程

使用SetWaitableTimer定时器前先了解一下几个函数：

HANDLE CreateWaitableTimer(
  LPSECURITY_ATTRIBUTES lpTimerAttributes, //安全描述符，可以为NULL        
  BOOL bManualReset, //是否为手动定时器，如果是手动的，需要调用SetWaitableTimer才能将定
时器变成信号的，如果是自动的，则调用WaitForsingleObject即可实现定时器信号的重置 
  LPCTSTR lpTimerName //定时器名称，这对于进程间的定时器来说是有用的。
);
BOOL bManualReset:用于指明人工重置的定时器或自动重置的定时器。当发出人工重置的定时器信号
通知时，等待该定时器的所有线程均变为可调度线程。当发出自动重置的定时器信号通知时，只有一
个等待的线程变为可调度线程。

BOOL SetWaitableTimer(
  HANDLE hTimer,                          // 定时器对象句柄
  const LARGE_INTEGER *pDueTime,          // 设定定时器从何时开始有信号
  LONG lPeriod,                           // 定时器周期
  PTIMERAPCROUTINE pfnCompletionRoutine,  // 回调函数
  LPVOID lpArgToCompletionRoutine,        // 传入回调函数参数
  BOOL fResume                          
);
HANDLE hTimer：定时器对象句柄
const LARGE_INTEGER *pDueTime：设定定时器从何时开始有信号，可以设置为一个特定的时刻，用
正值需要用到 FILETIME 结构，可以通过函数BOOL WINAPI SystemTimeToFileTime(const 
SYSTEMTIME *lpst, LPFILETIME lpft);将系统时间转换成FILETIME变量，如果FILETIME是绝对

时间，需通过LocalFileTimeToFileTime(CONST FILETIME *lpFileTime,LPFILETIME lpLocalFileTime)

将本地时间转换成全球标准时间，然后将FILETIME的时间转换成LARGE_INTEGER（注意：虽然FILETIEM结构

和LARGE_INTEGER结构的二进制格式完全相同，但不能直接把FILETIME结构传给LARGE_INTEGER结构，因为

这个两个结构的对齐方式是不同的。所有FILETIME结构的地址必须对齐到32位边界，而所有LARGE_INTEGER结构

的地址必须对齐到64位边界）；

或者用负值表示一个相对的时间，代表以100纳秒为单位的相对时间，（如从现在起的5秒钟，则设置为-50000000）
LONG lPeriod：设置定时器周期性的自我激发，该参数的单位为毫秒。如果为0，则表示定时器只发
出一次信号，大于0时，定时器没隔一段时间自动重新激活一个计时器，直至取消计时器使用
CancelWaitableTimer函数或重置使用SetWaitableTimer函数
BOOL fResume：如果为TRUE，而且系统支持电源管理，那么在计时器触发的时候，系统会退出省电模
式。如设为TRUE，但系统不支持省电模式，GetLastError就会返回ERROR_NOT_SUPPORTED 适用平台。
一般设为FALSE

DWORD WaitForSingleObject(
  HANDLE hHandle,        
  DWORD dwMilliseconds   
);
WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds
就返回，但如果参数dwMilliseconds为INFINITE时函数将直到相应时间事件变成有信号状态才返回，
否则就一直等待下去，直到 WaitForSingleObject有返回值才执行后面的代码。此外，当
dwMilliseconds设置为特殊值0时，测试hHandle核心对象是否被激发，函数立即返回。

DWORD SleepEx(
  DWORD dwMilliseconds,  
  BOOL bAlertable        
);
说明：将一个线程的运作挂起指定的时间
dwMilliseconds:将线程挂起的毫秒时间长度。如设为常数INFINITE，表示将一个线程永久性的催眠
bAlertable:如用一个ReadFileEx 或 WriteFileEx函数调用初始化了一个异步I/O传输，而且我们希
望函数返回，以便由那些函数指定的I/O结束例程能正常执行，就设为TRUE

使用SetWaitableTimer定时器时，你需要把常量_WIN32_WINNT定义为0x0400，并且此常量应该在包之
前定义，以确保声明合适的定时器原型函数。（此处暂时还不清楚）


1.设置手动重置定时器，当定时器一旦变成有信号时，那么WaitforsingleObject函数就会返回，并
且，变且定时器设置成非信号的。这里需要设置定时器函数中的参数二，参数三,四,五被忽略，使用
WaitforsingleObject即使有回调函数也是不会执行的。下面的例子没隔5s输出一次
WaitForSingleobject succeed。由于是设置的手动重置定时器，所以在while循环中需要
SetWaitableTimer重新设置一下定时器，否则会不停的输出WaitForSingleobject succeed，另外即
时这里设置的SetWaitableTimer的第三个参数定时周期大于0，也是没有意义的。

HANDLE hTime = CreateWaitableTimer(NULL, TRUE, NULL );
if ( NULL == hTime )
{
    cout << "hTime is NULL" << endl;
    return -1;
}

LARGE_INTEGER liDueTime;
liDueTime.QuadPart=-20000000; 
if ( !SetWaitableTimer(hTime, &liDueTime, 0, NULL, NULL, FALSE))
{
    cout << "SetWaitableTimer error" << endl;
    return -1;
}

while(1)
{
    if ( WaitForSingleObject(hTime, INFINITE) != WAIT_OBJECT_0 )
    {
        cout << "WaitForSingleObject error" << endl;
        return -1;
    }
    else
    {
        cout << "WaitForSingleobject succeed" << endl;
        SetWaitableTimer(hTime, &liDueTime, 0, NULL, NULL, FALSE);
    }
}
CloseHandle(hTime);

2.设置自动重置定时器，并设置定时器的周期相应时间，类似于普通定时器的用法，这里需要用APC的回调函数
HANDLE hTime = CreateWaitableTimer(NULL, FALSE, NULL );
if ( NULL == hTime )
{
    cout << "hTime is NULL" << endl;
    return -1;
}

LARGE_INTEGER liDueTime;
liDueTime.QuadPart=-20000000; 
if ( !SetWaitableTimer(hTime, &liDueTime, 2000, TimerProc, NULL, FALSE))
{
    cout << "SetWaitableTimer error" << endl;
    return -1;
}

while(1)
{
    SleepEx(INFINITE, TRUE);
}
CloseHandle(hTime);

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

原型：DWORD WaitForMultipleObjects(
DWORD nCount, // number of handles in array
CONST HANDLE *lpHandles, // object-handle array
BOOL bWaitAll, // wait option
DWORD dwMilliseconds // time-out interval
);

WaitForMultipleObjects函数用于等待多个内核对象，前两个参数分别为要等待的内核对象的个数和句柄数组指针。如果将第三个参数bWaitAll的值设为TRUE，等待的内核对象全部变成受信状态以后此函数才返回。否则，bWaitAll为0的话，只要等待的内核对象中有一个变成了受信状态，WaitForMultipleObjects就返回，返回值指明了是哪一个内核对象变成了受信状态。

实例一：

下面的代码说明了函数返回值的作用：

         HANDLE h[2];

         h[0] = hThread1;

         h[1] = hThread2;

         DWORD dw = ::WaitForMultipleObjects(2, h, FALSE, 5000);

         switch(dw)

         {       case WAIT_FAILED:

                            // 调用WaitForMultipleObjects函数失败(句柄无效？)

                            break;

                   case WAIT_TIMEOUT:

                            // 在5秒内没有一个内核对象受信

                            break;

                   case WAIT_OBJECT_0 + 0:

                            // 句柄h[0]对应的内核对象受信

                            break;

                   case WAIT_OBJECT_0 + 1:

                            // 句柄h[1]对应的内核对象受信

                            break;

         }

参数bWaitAll为FALSE的时候，WaitForMultipleObjects函数从索引0开始扫描整个句柄数组，第一个受信的内核对象将终止函数的等待，使函数返回。

实例二：

for(int i=0;i<6;i++)
{
   for(int j=0;j<10;j++)
   {
    theport[j].rmt_host=rmt_host;
    theport[j].p=port[i*10+j];
    theport[j].n=j;
    Thread[j]=AfxBeginThread(pScan,(LPVOID)&theport[j]);
    hThread[j]=Thread[j]->m_hThread;
    Sleep(1);
   }
   WaitForMultipleObjects(10,hThread,TRUE,120000);
}

注：线程退出后，即线程对象计数值变为0后，线程才会变为受信状态。

#vc程序设计

如果函数成功，返回值表示该事件导致该函数返回。这个值可以是下列之一。

ValueMeaning

WAIT_OBJECT_0到（WAIT_OBJECT_0 + nCount - 1如果bWaitAll为TRUE），则返回值表明所有指定对象的状态信号。

如果bWaitAll为FALSE，则返回值减去不是WAIT_OBJECT_0表示lpHandles数组的对象的满意指数的等待。如果多个对象在通话过程中信号成为，这是与所有的信号对象的最小索引值的信号对象的数组索引。

WAIT_ABANDONED_0至（WAIT_ABANDONED_0 + nCount -

如果bWaitAll为FALSE，则返回值减去WAIT_ABANDONED_0表示lpHandles满足等待一个废弃的互斥对象的数组索引

如果bWaitAll为FALSE，则返回值减去WAIT_ABANDONED_0表示一个废弃的互斥对象在lpHandles 数组中的下标，满足等待。

WAIT_TIMEOUTThe超时间隔已过，由bWaitAll参数指定的条件得不到满足。

===================================================

WaitForMultipleObjects是Windows中的一个功能非常强大的函数，几乎可以等待Windows中的所有的内核对象（关于该函数的描述和例子见MSDN，）。但同时该函数在用法上却需要一定的技巧。

原型：DWORD WaitForMultipleObjects(

 DWORD nCount,

 const HANDLE* lpHandles,

 BOOL bWaitAll,

 DWORD dwMilliseconds

);

 

当WaitForMultipleObjects等到多个内核对象的时候，如果它的bWaitAll 参数设置为false。其返回值减去WAIT_OBJECT_0 就是参数lpHandles数组的序号。如果同时有多个内核对象被出发，这个函数返回的只是其中序号最小的那个。

问题就在这里，我们如何可以获取所有被同时触发的内核对象。举个例子：我们需要在一个线程中处理从完成端口、数据库、和可等待定时器来的数据。一个典型的实现方法就是：用WaitForMultipleObjects等待所有的这些事件。如果完成端口，数据库发过来的数据量非常大，可等待定时器时间也只有几十毫秒。那么这些事件同时触发的几率可以说非常大，我们不希望丢弃任何一个被触发的事件。那么如何能高效地实现这一处理呢？

MSDN中有一句非常重要的描述，它可以说是WaitForMultipleObjects用法的精髓：The function modifies the state of some types of synchronization objects. Modification occurs only for the object or objects whose signaled state caused the function to return. For example, the count of a semaphore object is decreased by one. When bWaitAll is FALSE, and multiple objects are in the signaled state, the function chooses one of the objects to satisfy the wait; the states of the objects not selected are unaffected.

多个内核对象被触发时，WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。

这儿又会产生一个问题，如果序号最小的那个对象频繁被触发，那么序号比它大的内核对象将得不到被处理的机会。

为了解决这一问题，可以采用双WaitForMultipleObjects检测机制来实现。见下面的例子：

++++++++++++++++++++++++++++++++++++++++++++++++

[c-sharp] view plaincopy

1. DWORD WaitForMultipleObjects(  
2.   DWORD nCount,             // number of handles in the handle array  
3.   CONST HANDLE *lpHandles,  // pointer to the object-handle array  
4.   BOOL fWaitAll,            // wait flag  
5.   DWORD dwMilliseconds      // time-out interval in milliseconds  
6. );  
7.   
8. 其中参数   
9.   
10. nCount 句柄的数量 最大值为MAXIMUM_WAIT_OBJECTS（64）  
11.   
12. HANDLE 句柄数组的指针。  
13.   
14. HANDLE 类型可以为（Event，Mutex，Process，Thread，Semaphore ）数组  
15.   
16. BOOL bWaitAll 等待的类型，如果为TRUE 则等待所有信号量有效在往下执行，FALSE 当有其中一个信号量有效时就向下执行  
17.   
18. DWORD dwMilliseconds 超时时间 超时后向执行。 如果为WSA_INFINITE 永不超时。如果没有信号量就会在这死等。  
19.   
20. 举个例子：当 bWaitAll参数为FALSE 可以等待其中之一的事件  
21.   
22. HANDLE m_hEvent[2];    
23.   
24. //两事件  
25.   
26. m_hEvent[0]=::CreateEvent(NULL, FALSE, FALSE, NULL);  
27.   
28. m_hEvent[1]=::CreateEvent(NULL, FALSE, FALSE, NULL);  
29.   
30. ::CreateThread(NULL, 0, MyThreadProc, this, 0, NULL);  
31.   
32. DWORD WINAPI MyThreadProc(LPVOID lpParam)  
33.   
34. {   
35.   
36. while(TRUE)  
37.   
38.  {  //每次等500毫秒   
39.   
40.  int nIndex = ::WaitForMultipleObjects(2, pThis->m_hEvent, FALSE,500);     
41.   
42.  if (nIndex == WAIT_OBJECT_0 + 1)   
43.   
44.  {  
45.   
46.  //第二个事件发生   //ExitThread(0);   //break;    
47.   
48. }   
49.   
50.  else if (nIndex == WAIT_OBJECT_0) //第一个事件发生    
51.   
52. {   
53.   
54.   //第一个事件  
55.   
56.    }    
57.   
58. else if (nIndex == WAIT_TIMEOUT) //超时500毫秒    
59.   
60. {   //超时可作定时用    
61.   
62. }   
63.   
64. }  
65.   
66.  ::OutputDebugString("线程结束. /n");  
67.   
68.  return 0L;}  
69.   
70. 当要处理第一个事件时，你只需执行SetEvent(m_hEvent[0]);  
71.   
72. 即可进入第一个事件的位置  
73.   
74. 当要执行第二个事件时执行SetEvent(m_hEvent[1]);    
75.   
76.  当 bWaitAll参数为TRUE 等待所有的事件  
77.   
78.  DWORD WINAPI MyThreadProc(LPVOID lpParam)  
79.   
80. { while(TRUE)  
81.   
82.  {  //每次等500毫秒    
83.   
84. int nIndex = ::WaitForMultipleObjects(2, pThis->m_hEvent, TRUE,500);     
85.   
86.   if (WAIT_OBJECT_0 + 1<= nIndex <= WAIT_OBJECT_0) //所有事件发生   
87.   
88.  {   
89.   
90.   //所有的信号量都有效时（事件都发生）其中之一无效。   
91.   
92.  }   
93.   
94.   
95. 文章出处：http://www.diybl.com/course/3_program/c++/cppsl/2008711/132765.html  

当WaitForMultipleObjects()等到多个内核对象的时候，

如果它的bWaitAll 参数设置为false。其返回值减去WAIT_OBJECT_0 就是参数lpHandles数组的序号。

如果同时有多个内核对象被出发，这个函数返回的只是其中序号最小的那个。

问题就在这里，我们如何可以获取所有被同时触发的内核对象。

举个例子：我们需要在一个线程中处理从完成端口、数据库、和可等待定时器来的数据。

一个典型的实现方法就是：用WaitForMultipleObjects等待所有的这些事件。

如果完成端口，数据库发过来的数据量非常大，可等待定时器时间也只有几十毫秒。

那么这些事件同时触发的几率可以说非常大，我们不希望丢弃任何一个被触发的事件。那么如何能高效地实现这一处理呢？

 

多个内核对象被触发时，WaitForMultipleObjects选择其中序号最小的返回。而WaitForMultipleObjects它只会改变使它返回的那个内核对象的状态。
这儿又会产生一个问题，如果序号最小的那个对象频繁被触发，那么序号比它大的内核对象将的不到被出理的机会。
 为了解决这一问题，可以采用双WaitForMultipleObjects检测机制来实现。见下面的例子：

 

[cpp] view plaincopy

1. DWORD WINAPI ThreadProc(LPVOID lpParameter)  
2. {  
3. DWORD dwRet = 0;  
4. int nIndex = 0;   
5. while(1)  
6. {dwRet = WaitForMultipleObjects(nCount,pHandles,false,INFINITE);  
7. switch(dwRet)  
8. {  
9. case WAIT_TIMEOUT:  
10. break;  
11. case WAIT_FAILED:  
12. return 1;   
13. default:   
14. {   
15. nIndex = dwRet - WAIT_OBJECT_0;   
16. ProcessHanlde(nIndex++); //同时检测其他的事件 while(nIndex < nCount)  
17. {  
18. dwRet = WaitForMultipleObjects(nCount - nIndex,&pHandles[nIndex],false,0);  
19. switch(dwRet)  
20. case WAIT_TIMEOUT:   
21. nIndex = nCount; //退出检测,因为没有被触发的对象了.   
22. break;  
23. case WAIT_FAILED:  
24. return 1;  
25. default:   
26. { nIndex = dwRet - WAIT_OBJECT_0;  
27. ProcessHanlde(nIndex++);  
28. }   
29. break;  
30. }  
31. }  
32. }  
33. break;  
34. }  
35. }   
36. return 0;  
37. }  

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

/*TimerThread (WIN32) free version 1.2 for WIN2000Compiled by： BC++ 5(free tool); C++ BUILDER 4, 5, 6, X; VC++ 5, 6, 7, 8;  GCC;Writer: llbird Mail  : [e-mail]  Blog  : http://blog.csdn.net/wujian53Copyright(c) 2004.5 - 2006.1 *//*#if (_WIN32_WINDOWS < 0x0500)#error     the code need _WIN32_WINDOWS >= 0x0500#endif */  #ifndef _TIMER_THREAD_H_#define    _TIMER_THREAD_H_#include <objbase.h>#include <winbase.h>#include <windows.h>#include <process.h> #include "assert.h"class TimerThread {public:TimerThread(int nPriority = THREAD_PRIORITY_NORMAL){_TerminateEvent = CreateEvent(0, TRUE, FALSE, NULL);_TimerHandle = CreateWaitableTimer(NULL, FALSE, NULL);::InitializeCriticalSection(&_Mutex);#ifdef _MTunsigned int id;_hHandle = (HANDLE)_beginthreadex(NULL, 0, StaticThreadProc, this, 0, &id);#elseDWORD id;_hHandle = ::CreateThread(NULL, 0, StaticThreadProc, this, 0, &id); #endif_ThreadID = id;if(_hHandle != NULL)SetThreadPriority(_hHandle, nPriority);elseMessageBox(NULL, "Create thread fail!", "TimerThread", MB_OK);}virtual ~TimerThread(){Terminate();CloseHandle(_hHandle);CloseHandle(_TimerHandle);CloseHandle(_TerminateEvent);::DeleteCriticalSection(&_Mutex);}bool SetTimer(LONG lPeriodTime)//ms{_lPeriodTime = lPeriodTime;LARGE_INTEGER li;memset(&li, 0, sizeof(LARGE_INTEGER));return SetWaitableTimer(_TimerHandle, &li, _lPeriodTime, NULL, NULL, FALSE)!=0;}void Terminate(){SetEvent(_TerminateEvent);if(WaitForSingleObject(_hHandle, 200) != WAIT_OBJECT_0)TerminateThread(_hHandle, 0);}operator HANDLE(){return _hHandle;}HANDLE GetHandle(){return _hHandle;}///关联消息的窗口句柄inline void SetWnd(HWND hWnd){assert(::IsWindow(hWnd));_hNotifyWnd = hWnd;}LONG GetFinishedCount(){return _TimerHandleCount;}struct InnerLock{TimerThread* ptr;InnerLock(TimerThread* p) : ptr(p){ptr->Lock();}~InnerLock(){ptr->Unlock();}};///锁定资源void Lock(){::EnterCriticalSection(&_Mutex);}void Unlock(){::LeaveCriticalSection(&_Mutex);}protected:HANDLE _TerminateEvent;HANDLE _TimerHandle;HANDLE _hHandle;unsigned _ThreadID;HWND _hNotifyWnd;  ////// 通知窗口LONG _TimerHandleCount;LONG _lPeriodTime;CRITICAL_SECTION _Mutex;//初始化virtual void OnInit(){}//定时器函数virtual void OnTimer()=0;//退出virtual void OnExit(){}virtual void Run(){HANDLE HandleArray[2];HandleArray[0] = _TimerHandle;HandleArray[1] = _TerminateEvent;for(;;){DWORD ret = WaitForMultipleObjects(2, HandleArray, false, INFINITE);if(ret == WAIT_OBJECT_0 + 1)break;if(ret == WAIT_OBJECT_0){try{OnTimer();}catch (...){}InterlockedIncrement(&_TimerHandleCount);}}}#ifdef _MTstatic UINT APIENTRY StaticThreadProc(LPVOID lpPara) //允许C多线程运行库#elsestatic DWORD WINAPI StaticThreadProc(LPVOID lpPara)#endif{TimerThread *pObj = (TimerThread*)lpPara;pObj->OnInit();pObj->Run();pObj->OnExit();#ifdef _MT_endthreadex(0);#endifreturn 0;}};#endif _TIMER_THREAD_H_