CSDN博客

img skyremember

CreateEvent的用法

发表于2008/9/29 7:00:00  65955人阅读

 CreateEvent的用法收藏

新一篇: PreCreateWindow的作用和使用方法 | 旧一篇: VC中_T()的作用

事件对象就像一个开关:它只有两种状态---开和关。当一个事件处于”开”状态,我们称其为”有信号”否则称为”无信号”。可以在一个线程的执行函数中创建一个事件对象,然后观察它的状态,如果是”无信号”就让该线程睡眠,这样该线程占用的CPU时间就比较少。

产生事件对象的函数如下:  

HANDLE     CreateEvent(

        LPSECURITY_ATTRIBUTES     lpEventAttributes,     //     SD   
        BOOL     bManualReset,                                                 //     reset     type   
        BOOL     bInitialState,                                                      //     initial     state   
        LPCTSTR     lpName                                                       //     object     name   
    );   
    该函数创建一个Event同步对象,如果CreateEvent调用成功的话,会返回新生成的对象的句柄,否则返回NULL。

参数说明:
    lpEventAttributes     一般为NULL   


    bManualReset               创建的Event是自动复位还是人工复位.如果true,人工复位,   一旦该Event被设置为有信号,则它一直会等到ResetEvent()API被调用时才会恢复 为无信号.     如果为false,Event被设置为有信号,则当有一个wait到它的Thread时,  该Event就会自动复位,变成无信号.   如果想 在每次调用WaitForSingleObject 后让WINDOWS为您自动地把事件地状态恢复为”无信号”状态,必须把该参数设为FALSE,否则,您必须每次调用ResetEvent函数来清除事件 的信号。


    bInitialState             初始状态,true,有信号,false无信号   
    lpName                  事件对象的名称。您在OpenEvent函数中可能使用。

注释:
    一个Event被创建以后,可以用OpenEvent()API来获得它的Handle,用CloseHandle()    来关闭它,用SetEvent()或PulseEvent()来设置它使其有信号,用ResetEvent()       来使其无信号,用WaitForSingleObject()或WaitForMultipleObjects()来等待其变为有信号.   
   
    PulseEvent()是一个比较有意思的使用方法,正如这个API的名字,它使一个Event 对象的状态发生一次脉冲变化,从无信号变成有信号再变成无信号,而整个操作是原子的.   
    对自动复位的Event对象,它仅释放第一个等到该事件的thread(如果有),而对于人工复位的Event对象,它释放所有等待的thread.  
 

 
这里有两个API函数用来修改事件对象的信号状态:SetEvent和ResetEvent。前者把事件对象设为”有信号”状态,而后者正好相反。
在事件对象生成后,必须调用WaitForSingleObject来让线程进入等待状态,该函数的语法如下:  

WaitForSingleObject proto hObject:DWORD, dwTimeout:DWORD  

hObject -->指向同步对象的指针。事件对象其实是同步对象的一种。
dwTimeout --> 等待同步对象变成”有信号”前等待的时间,以毫秒计。当等待的时间超过该值后无信号同步对象仍处于”无信号”状态,线程不再等待, WaitForSingleObject函数会返回。如果想要线程一直等待,请把该参数设为INFINITE(该值等于0xffffffff)。  

发表于 @ 2008年04月18日 13:30:00|评论(0)|编辑

新一篇: PreCreateWindow的作用和使用方法 | 旧一篇: VC中_T()的作用



 Visual C++中的多线程收藏

新一篇: 特洛伊木马(一) | 旧一篇: 用户接口与作业调度

以前,曾经研究过了java中的多线程问题,特别是加锁和同步问题,但是,在C++中,确没有这么简单了。由于C没有提供像java里的线程类,一些同步的实现必须靠自己程序实现,稍显复杂。
一般来说,在C++里面创建和终止线程的函数为:_beginthread和_endthread两个函数,当然,也可以用CreateThread和ExitThread。具体的使用方式可以查看msdn。
那么,怎么样实现加锁与同步呢?可以使用createMutex函数以及createEvent方法等来实现,具体可以参考下例:

#include 
< iostream>
#include 
< windows.h>

using namespace std;
#define BUFSIZE 5
int SharedBuffer[BUFSIZE];
int head,tail;
int count;
HANDLE hMutex;
HANDLE hNotFullEvent, hNotEmptyEvent;
void BB_Producer()
{
int i;
for (i=20; i>=0; i--{
while(1{
WaitForSingleObject(hMutex,INFINITE);
if (count == BUFSIZE) // 缓冲区满
ReleaseMutex(hMutex);
// 等待直到缓冲区非满
WaitForSingleObject(hNotFullEvent,INFINITE);
continue;
}

// 得到互斥锁且缓冲区非满,跳出while循环
break;
}

// 得到互斥锁且缓冲区非满,开始产生新数据
cout << "Produce: " << i << endl;
SharedBuffer[tail] 
= i;
tail 
= (tail+1% BUFSIZE;
count
++;
ReleaseMutex(hMutex); 
// 结束临界区
PulseEvent(hNotEmptyEvent); // 唤醒消费者线程
}

}

void BB_Consumer()
{
int result;
while (1{
WaitForSingleObject(hMutex,INFINITE);
if (count == 0// 没有可以处理的数据
ReleaseMutex(hMutex); // 释放互斥锁且等待
// 等待直到缓冲区非空
WaitForSingleObject(hNotEmptyEvent,INFINITE);
}

else if (SharedBuffer[head] == 0{
cout 
<< "Consumed 0: end of data" << endl;
ReleaseMutex(hMutex); 
// 结束临界区
ExitThread(0);
}

else // 获得互斥锁且缓冲区有数据,开始处理
result = SharedBuffer[head];
cout 
<< "Consumed: " << result << endl;
head 
= (head+1% BUFSIZE;
count
--;
ReleaseMutex(hMutex); 
// 结束临界区
PulseEvent(hNotFullEvent); // 唤醒生产者线程
}

}

}

void main()
{
HANDLE hThreadVector[
2];
DWORD ThreadID;
count 
= 0;
head 
= 0;
tail 
= 0;
hMutex 
= CreateMutex(NULL,FALSE,NULL);
hNotFullEvent 
= CreateEvent(NULL,TRUE,FALSE,NULL);
hNotEmptyEvent 
= CreateEvent(NULL,TRUE,FALSE,NULL);
hThreadVector[
0= CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) BB_Producer,
NULL, 
0, (LPDWORD)&ThreadID);
hThreadVector[
1= CreateThread (NULL, 0,
(LPTHREAD_START_ROUTINE) BB_Consumer,
NULL, 
0, (LPDWORD)&ThreadID);
WaitForMultipleObjects(
2,hThreadVector,TRUE,INFINITE);
}
这是一个典型的生产者-消费者问题,它们公用的资源是SharedBuffer,当Buffer中有数据且未满时,两个线程都可以运行,当Buffer为 空时,Consumer就要等待,直到Buffer不为空,这里就是用event来实现的;同样,当Buffer为满时,Producer就要等待。

发表于 @ 2006年10月29日 19:54:00|评论(2)|编辑

新一篇: 特洛伊木马(一) | 旧一篇: 用户接口与作业调度


Windows API一日一练(45)CreateEvent和SetEvent函数收藏

新一篇: Windows API一日一练(46)EnterCriticalSection和LeaveCriticalSection函数 | 旧一篇: Windows API一日一练(44)wsprintf函数

当你创建一个线程时,其实那个线程是一个循环,不像上面那样只运行一次的。这样就带来了一个问题,在那个死循环里要找到合适的条件退出那个死循环,那么是怎么样实现它的呢?在Windows里往往是采用事件的方式,当然还可以采用其它的方式。在这里先介绍采用事件的方式来通知从线程运行函数退出来,它的实现原理是这样,在那个死循环里不断地使用WaitForSingleObject函数来检查事件是否满足,如果满足就退出线程,不满足就继续运行。当在线程里运行阻塞的函数时,就需要在退出线程时,先要把阻塞状态变成非阻塞状态,比如使用一个线程去接收网络数据,同时使用阻塞的SOCKET时,那么要先关闭SOCKET,再发送事件信号,才可以退出线程的。下面就来演示怎么样使用事件来通知线程退出来。
 
函数CreateEvent声明如下:
 
WINBASEAPI
__out
HANDLE
WINAPI
CreateEventA(
    __in_opt LPSECURITY_ATTRIBUTES lpEventAttributes,
    __in     BOOL bManualReset,
    __in     BOOL bInitialState,
    __in_opt LPCSTR lpName
    );
WINBASEAPI
__out
HANDLE
WINAPI
CreateEventW(
    __in_opt LPSECURITY_ATTRIBUTES lpEventAttributes,
    __in     BOOL bManualReset,
    __in     BOOL bInitialState,
    __in_opt LPCWSTR lpName
    );
#ifdef UNICODE
#define CreateEvent CreateEventW
#else
#define CreateEvent CreateEventA
#endif // !UNICODE
lpEventAttributes是事件的属性。
bManualReset是指事件手动复位,还是自动复位状态。
bInitialState是初始化的状态是否处于有信号的状态。
lpName是事件的名称,如果有名称,可以跨进程共享事件状态。
 
调用这个函数的例子如下:
#001 #pragma once
#002 
#003 //线程类。
#004 //蔡军生 2007/09/23 QQ:9073204
#005 class CThread
#006 {
#007 public:
#008 
#009  CThread(void)
#010  {
#011          m_hThread = NULL;
#012          m_hEventExit = NULL;
#013  }
#014 
#015  virtual ~CThread(void)
#016  {
#017         if (m_hThread)
#018         {
#019               //删除的线程资源。
#020               ::CloseHandle(m_hThread);
#021         }
#022 
#023         if (m_hEventExit)
#024         {
#025               //删除事件。
#026               ::CloseHandle(m_hEventExit);
#027         }
#028        
#029  }
#030 
#031  //创建线程
#032  HANDLE CreateThread(void)
#033  {
#034         //创建退出事件。
#035         m_hEventExit = ::CreateEvent(NULL,TRUE,FALSE,NULL);
#036         if (!m_hEventExit)
#037          {
#038               //创建事件失败。
#039               return NULL;
#040         }
#041 
#042         //创建线程。
#043          m_hThread = ::CreateThread(
#044               NULL,                    //安全属性使用缺省。
#045               0,                         //线程的堆栈大小。
#046               ThreadProc,                 //线程运行函数地址。
#047               this,                      //传给线程函数的参数。
#048               0,                         //创建标志。
#049               &m_dwThreadID);        //成功创建后的线程标识码。
#050 
#051         return m_hThread;
#052  }
#053 
#054  //等待线程结束。
#055  void WaitFor(DWORD dwMilliseconds = INFINITE)
#056  {
#057         //发送退出线程信号。
#058        ::SetEvent(m_hEventExit);
#059 
#060         //等待线程结束。
#061         ::WaitForSingleObject(m_hThread,dwMilliseconds);
#062  }
#063 
#064 protected:
#065  //
#066  //线程运行函数。
#067  //蔡军生 2007/09/21
#068  //
#069  static DWORD WINAPI ThreadProc(LPVOID lpParameter)
#070  {
#071         //转换传送入来的参数。
#072         CThread* pThread = reinterpret_cast<CThread *>(lpParameter);
#073         if (pThread)
#074         {
#075               //线程返回码。
#076               //调用类的线程处理函数。
#077               return pThread->Run();
#078         }
#079        
#080         //
#081         return -1;       
#082  }
#083 
#084  //线程运行函数。
#085  //在这里可以使用类里的成员,也可以让派生类实现更强大的功能。
#086  //蔡军生 2007/09/25
#087  virtual DWORD Run(void)
#088  {
#089         //输出到调试窗口。
#090         ::OutputDebugString(_T("Run()线程函数运行/r/n"));     
#091 
#092         //线程循环。
#093         for (;;)
#094         {
#095              DWORD dwRet = WaitForSingleObject(m_hEventExit,0);
#096               if (dwRet == WAIT_TIMEOUT)
#097               {
#098                    //可以继续运行。                
#099                    TCHAR chTemp[128];
#100                    wsprintf(chTemp,_T("ThreadID=%d/r/n"),m_dwThreadID);
#101                    ::OutputDebugString(chTemp);
#102 
#103                     //目前没有做什么事情,就让线程释放一下CPU
#104                    Sleep(10);
#105               }
#106               else if (dwRet == WAIT_OBJECT_0)
#107               {
#108                    //退出线程。
#109                    ::OutputDebugString(_T("Run() 退出线程/r/n"));
#110                    break;
#111               }
#112               else if (dwRet == WAIT_ABANDONED)
#113               {
#114                    //出错。
#115                    ::OutputDebugString(_T("Run() 线程出错/r/n"));
#116                    return -1;
#117               }
#118         }
#119 
#120         return 0;
#121  }
#122 
#123 protected:
#124  HANDLE m_hThread;         //线程句柄。
#125  DWORD m_dwThreadID;          //线程ID
#126 
#127  HANDLE m_hEventExit;    //线程退出事件。
#128 };
#129 
 
上面在第35行创建线程退出事件,第95行检查事件是否可退出线程运行,第58行设置退出线程的事件。
 

发表于 @ 2007年09月25日 21:32:00|评论(0)|编辑

新一篇: Windows API一日一练(46)EnterCriticalSection和LeaveCriticalSection函数 | 旧一篇: Windows API一日一练(44)wsprintf函数


Win32 API 常用函数之二收藏

新一篇: Win32 API 常用函数之三——注册表操作(上) | 旧一篇: Win32 API 常用函数之一

【事件】
       事件用处多是控制线程间的同步。
       最典型的应用就是CreateThread之后等待线程函数的启动。如Main线程里CreateThread,它之后的操作依赖于子线程,那么它一般会 在CreateThread之后判断HANDLE是否有效,然后进入等待。(当然在这之前,一个Event是已经创建好的,并初始化为未通知状态)子线程 启动后完成了初始化操作,并设置Event为已通知状态。这时,一直在等待该事件的Main线程发现该事件已经得到通知,因此它就变成可调度线程。这时 Main线程知道子线程已经完成了初始化操作。
       CreateEvent函数用于创建一个Event,其原型如下:
HANDLE CreateEvent(
  LPSECURITY_ATTRIBUTES lpEventAttributes, 
  BOOL bManualReset, 
  BOOL bInitialState, 
  LPTSTR lpName 
); 
       参数说明:
  1. 第一个参数同CreateThread类似,也是安全级别相关,通常被被设置为NULL,以获得默认的安全级别。
  2. 第二个参数是个布尔值,它能够告诉系统是创建一个人工重置的事件(TRUE)还是创建一个自动重置的事件( FALSE)。
  3. 第三个参数也是布尔值,用于指明该事件是要初始化为已通知状态(TRUE)还是未通知状态(FALSE)。
  4. 第四个参数是一个字符串,用于标示这个事件的名字。
       以下是详细说明:
  1. 已通知状态和未通知状态
    事件只有两种状态,已通知表示这个事件已经被设置过了(可以理解为发生了),未通知表示还没有发生。一般设置为未通知状态,并由SetEvent设置为已 通知状态。当然也可以反着做,CreateEvent时设置为已通知状态,然后由ResetEvent设置为未通知状态。
  2. 人工重置与自动重置
    自动重置的事件定义了应该成功等待的副作用规则,即当线程成功地等待到该对象时,自动重置的事件就会自动重置到未通知状态。
    人工重置则需要调用ResetEvent函数设置为未通知状态。
  3. 名字共享
    这个参数很重要,Win32 API中有很多方法有这个参数,它遵从一种按名字共享的规则。
    如果传入一个非NULL字符串(最多260个字符),那么在全局空间,共享该HANDLE,这个全局可以是跨进程的名字空间,即在另一个进程中依然能够使用该名字的HANDLE。
    如果希望避免这种全局范围内的共享,那么应该传入NULL,以一种匿名的方式创建Event等,这样,它只在当前线程内可见。
        当进程A创建了一个Event后,如CreateEvent(NULL,FALSE,FLASE,_T(“UniqueEvent”));进程B同样创建 了一个Event,也想起名字为UniqueEvent,那么就会出现问题:CreateEvent(NULL,FALSE,FALSE,_T (“UniqueEvent”));系统会首先查看是否已经存在了一个名字为“UniqueEvent”的对象,由于确实存在了一个带有改名字的内核对 象,因此内核要检查对象类型,同样是一 个Event,那么系统会执行一次安全检查,以确定调用者是否拥有对该对象的完整访问权。如果有这种访问权,系统会在进程B的句柄表里找到一个空项目,对 其初始化,使得该项指向现有的内核对象。如果类型不匹配,或者拒绝访问,那么进程B的CreateEvent会失败。
       应用程序能够确定它是否确实创建了一个新内核对象,而不是打开了一个现有的对象。方法是在调用C r e a t e *函数后立即调用G e t L a s t E r r o r:如果为ERROR_ALREADY_EXISTS,那么表示系统内已经存在了这样名字的对象。
       Open*是去查看名字空间中是否有这个名字的内核对象存在调用C r e a t e *函数与调用O p e n *函数之间的主要差别是,如果对象并不存在,那么C r e a t e *函数将创建该对象,而O p e n *函数则运行失败。

       PulseEvent函数使得事件变为已通知状态,然后立即又变为未通知状态,这就像在调用SetEvent后又立即调用ResetEvent函数一样。 如果在人工重置的事件上调用PulseEvent函数,那么在发出该事件时,等待该事件的任何一个线程或所有线程将变为可调度线程。如果在自动重置事件上 调用P u l s e E v e n t函数,那么只有一个等待该事件的线程变为可调度线程。如果在发出事件时没有任何线程在等待该事件,那么将不起任何作用。

【等待函数】
       等待函数用来监听事件的已通知状态。WaitForSingleObject和WaitForMultipleObjects两个函数分别用以等待单个事件和多个事件。
DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD dwMilliseconds
);
DWORD WaitForMultipleObjects(
  DWORD nCount,
  
const HANDLE* lpHandles,
  BOOL bWaitAll,
  DWORD dwMilliseconds
);
       从函数原型上来看可知,事件的含义是能够支持被通知/未通知的内核对象(例如进程和线程,当传入的是进程或者线程句柄时,他表示等该线程或进程被标识为终止运行为止。)。
       dwMilliseconds 参数表明等待的时间,如果在这个时间段中事件为已通知状态,那么对于Single版本将返回WAIT_OBJECT_0,对于Multiple版本将返回 WAIT_OBJECT_0 to (WAIT_OBJECT_0 + nCount– 1)。如果没有等到将返回WAIT_TIMEOUT。
       Multiple版本中的bWaitAll表示想要让它使用何种方式等待。如果为该参数传递TRUE,那么在所有对象变为已通知状态之前,该函数将不允许调用线程运行。一般是FALSE,即只要有一个事件被相应,则线程可调度。

      

发表于 @ 2007年10月28日 18:04:00|评论(0)|编辑

新一篇: Win32 API 常用函数之三——注册表操作(上) | 旧一篇: Win32 API 常用函数之一

2 0

相关博文

我的热门文章

img
取 消
img