MFC线程相关

最新推荐文章于 2019-06-05 12:03:53 发布

小城攻城狮

最新推荐文章于 2019-06-05 12:03:53 发布

阅读量5.5k

点赞数

分类专栏： MFC

MFC 专栏收录该内容

3 篇文章

订阅专栏

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

);

参数说明：

第一个参数同CreateThread类似，也是安全级别相关，通常被被设置为NULL，以获得默认的安全级别。
第二个参数是个布尔值，它能够告诉系统是创建一个人工重置的事件（TRUE）还是创建一个自动重置的事件（ FALSE）。
第三个参数也是布尔值，用于指明该事件是要初始化为已通知状态（TRUE）还是未通知状态（FALSE）。
第四个参数是一个字符串，用于标示这个事件的名字。

以下是详细说明：

已通知状态和未通知状态
事件只有两种状态，已通知表示这个事件已经被设置过了（可以理解为发生了），未通知表示还没有发生。一般设置为未通知状态，并由SetEvent设置为已通知状态。当然也可以反着做，CreateEvent时设置为已通知状态，然后由ResetEvent设置为未通知状态。
人工重置与自动重置
自动重置的事件定义了应该成功等待的副作用规则，即当线程成功地等待到该对象时，自动重置的事件就会自动重置到未通知状态。
人工重置则需要调用ResetEvent函数设置为未通知状态。
名字共享
这个参数很重要，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，即只要有一个事件被相应，则线程可调度。

转自：