[cpp] view plaincopy

[cpp] view plaincopy

[cpp] view plaincopy

[cpp] view plaincopy

1. <span style="font-size:18px;">DWORD WatiForSingleObject(
2. 　　　HANDLE hObject,
3. 　　　DWORD dwMilliseconds);</span>

1. <span style="font-size:18px;">DWORD dw=WaitForSingleObject(hProcess,5000);
2. switch(dw)
3. {
4. cse WAIT_OBJECT_0://规定的时间内等待成功。
5. break;
6. case WAIT_TIMEOUT://超时。
7. 　　　           break;
8. 　　　case WAIT_FAILED://指定的句柄无效。
9. 　　　        break;
10. 　　　Default:
11. 　　　      break;
12. }</span>

1. <span style="font-size:18px;">DWORD WaitForMultipleOBjecs（
2. 　　　DWORD dwCount,
3. 　　　CONST HANDLE*pbObject,
4. 　　　BOOL bWaitAll,
5. 　　　DWORD dwMilliseconds);</span>

1. <span style="font-size:18px;">HANDLE h[3];
2. H[0]=hProcess1;
3. H[1=hProcess2;
4. H[2]=hProcess3;
5. DWORD dw=WaitForMultipleOBjecs(3,H,false,5000);
6. switch(dw)
7. {
8. case WAIT_OBJEC_0://第一个对象被触发。
9. break;
10. case WAIT_OBJEC_0+1://第二个对象被触发。
11. break;
12. case WAIT_OBJEC_0+2://第三个对象被触发。
13. break;
14. case WAIT_TIMEOUT://超时
15. break;
16. case WAIT_FAILED://句柄无效。
17. break;
18. }</span>

事件内核对象

事件内核对象是在线程同步时比较常用的内核对象。

一个事件内核对象的触发表示一个操作已经完成。有两种类型的事件内核对象：手动重置事件和自动重置事件。

所谓自动重置事件，就是当线程等待自动重置事件成功后，对象将自动重置成非触发状态。这也正是自动重置事件的由来。

而手动重置事件必须手动设置成自动重置事件。

一个手动重置事件对象触发时，所有等待此对象的线程都变成了可调度状态。而一个自动重置事件变成触发时在所有等待该内核对象触发的线程中只有一个可以变成可调度状态。

使用CreateEvent可以创建一个事件内核对象。

psa表示内核对象的安全属性。赋值NULL，表示使用默认的安全属性。（前面对安全属性有详细的介绍）。

bManualReset指定要创建的内核对象是手动重置还是自动重置内核对象。

bInitialState指定事件对象的初始状态。触发或未触发。

pszName指定该内核对象的名称。可用于跨进称共享内核对象。

当调用此函数成功时，CreateEvent将返回一个事件内核对象的句柄。

此外还有CreateEventEx函数对对象的权限进行控制，此处不再介绍。

前面我们提到过内核对象可以实现跨进称线程同步。要实现此功能，必须能在其他进程中访问此内核对象。这可以通过一下几种方式：

1：调用CreateEvent时，指定pszName与已存在的事件内核对象同名。此时与OpenEvent功能相同。

2:使用继承。

3：使用DuplicateHandle函数。

该函数会打开pszName指定名称的已存在的内核对象。如果为CreateEvent指定pszName，此名称已存在且类型相同都为事件内核对象，则CreateEvent也仅仅是打开此内核对象获得句柄。只有当此名称的内核对象不存在或类型不同时才创建新的内核对象。

不使用内核对象时要调用CloseHandle关闭对它的引用。

SetEvent可以将事件内核对象变为触发态。

ResetEvent可以把事件内核对象变为未触发状态。

事件内核对象在线程同步中经常使用。接下来介绍一个例子：

可等待的计时器内核对象。

可等待计时器对象，会在某个指定的时间触发或每隔一段时间出发一次。可以调用CreateWaitableTimer创建可等待计时器对象。

psa和pszName分别表示安全属性和名称。不再介绍。

bManualReset表示要创建的是一个手动重置计时器还是自动重置计时器。当手动重置计时器被触发，正在等待该计时器的所有线程都变成可调度状态。当自动重置计时器被触发时，只有一个等待该计时器的线程变成可调度状态。

OPenWaitableTimer可以打开一个已经存在的计时器对象并返回该计时器对象的句柄。

刚创建的计时器内核对象总是处于未触发状态。当我们想要触发计时器时还需要调用SetWaitableTimer;

hTimer表示我们要触发的计时器。

pDueTime和lPeriod要配合使用。pDueTime表示计时器第一次触发的时间。lPeriod表示在第一次触发之后，计时器的触发频度，它们都是以毫秒为单位。

上述代码的SYSTEMTIME结构指定第一次触发时间。这个是本地时间。由于SetWaitableTimer的第二个参数是LARGE_INTEGER结构因此不能将它们之间转换。但是FILETIME结构和LARGE_INTEGER结构二进制格式完全相同。我们可以将SYSTEMTIME结构转换为FILETIME结构。由于SetWaitableTimer需要全球标准时间，因此需要调用LocalFileTimeToFileTime完成转换。

由于FILETIME和LARGE_INTEGER二进制格式完全相同。我们更倾向于直接把FILETIME结构传给SetWaitableTimer。

如

但是上述代码存在问题。虽然FILETIME和LARGE_INTEGER二进制形式相同，但是它们对其的方式不同。FILETIME结构必须对齐到32位边界。而LARGE_INTEGER结构必须对齐到64位边界。因此直接传递FILTTIME结构可能会出现问题。推荐的方式是先把FILETIME的成员复制到LARGE_INTEGER的成员中，再把LARGE_INTEGER的地址传给SetWaitableTimer。

除了指定一个绝对时间之外，还可以指定一个相对时间。此时只需要将pDuetime传入负值，此时是以100微秒为单位。

下面的代码把计时器第一次触发的时间设为调用结束后的5s后。

此后每隔6小时出发一次。

如果lPeriod传入0，那么计时器只触发一次，以后不再触发。

bResume用以支持挂起。一般都传入false。当传入true时，当计时器被触发时，系统就会使机器结束挂起模式，并唤醒等待该计时器的线程。当为false时，计时器会被触发，但是如果此时机器处于挂起态时，在机器继续执行之前，被唤醒的任何线程都得不到cpu。

最后介绍CancelWaitableTimer

该函数会将句柄所标识的计时器取消。此后计时器就不会再触发。要想让计时器继续触发，可以再次调用SetWaitableTimer。

用户计时器

相信大家在使用VC时一定接触过用户计时器。它通过SetTimer来设置。但是好多人对它与可等待计时器混淆不清。其实，两者最大区别就是用户计时器需要在用户程序中使用大量的用户界面基础设施，从而消耗更多的资源。而可等待计时器是内核对象，不仅可以在多线程间共享而且具备安全性 。用户计时器会产生WM_TIMER消息，这个消息被送到SetTimer设置的回调函数。此时只有一个线程得到通知。而可等待计时器对象可以被多个线程等待。

如果打算在计时器被触发时执行与用户界面相关的操作。使用用户计时器可使代码更容易编写。

信号量内核对象

信号量内核对象用来对资源进行计数。与其他内核对象相同，它包括一个使用计数。但是它还包含另外两个值：一个是最大资源计数和当前资源计数。最大资源计数表示信号量可以控制的最大资源数量。当前资源计数表示信号量当前可用资源的数量。

假设有个服务器进程，它有一块内存，用可以存储5个客户端请求。如果第六个客户端请求时它将会被拒绝 。此时缓冲区内客户端的请求就是看作资源。我们可以使用信号量来保护资源。首先我们创建信号量并将最大资源计数设为5。由于还没有客户端请求，当前资源计数被初始化为0。随着不断有客户端发出请求，进入请求队列当前资源计数随之递增。随着服务器不断接受客户端请求，请求队列请求减少当前资源使用计数随之递减。

信号量的规则如下：

1：如果当前资源计数大于0，那么信号量处于触发状态（说明有资源可被使用，所有等待线程被调度）。

2：如果当前资源计数等于0，那么信号量处于未触发状态（没有可用资源，所有线程等待）。

3：当前资源计数不会小于0.

4：当前可用资源计数不会大于最大资源计数。

注意：使用信号量时不要将信号量的使用计数和当前资源计数混为一谈。

创建信号量对象：

lMaximumCount告诉系统应用程序能够处理的资源最大数量。

lInitialCount表示这些资源一开始有多少可供使用。

与此对应的有OpenSemaphore。它打开一个已存在的信号量对象

为了获得对被保护资源的访问权，线程要调用一个等待函数并传入信号量句柄。在内部等待函数会检查信号量的当前资源计数。如果它的值大于0，那么等待函数会把可用资源数减一并让调度线程继续执行。如果等待函数发现信号量当前资源计数为0，那么系统会让线程进入等待状态。当另一个线程将信号量的当前资源计数递增时，原来由于等待资源被挂起的线程会被唤醒。

线程通过ReleaseSemaphore来递增信号量的当前计数。

lReleaseCount值被加到当前资源计数上。一般传入1。

plPreviousCount返回加之前的值。这个信号量对象在当前基础上所要增加的值，这个值必须大于0。如果信号量加上这个值会导致信号量的当前值大于信号量创建时指定的最大值，那么这个信号量的当前值不变，同时这个函数返回FALSE。plPreviousCount值不确定。

如果不需要信号量上次的值，那么这个参数可以设置为NULL。

互斥量对象

互斥量内核对象用来确保一个线程独占第一个资源的访问。互斥量对象包括一个使用计数、线程ID以及一个递归计数。

互斥量与关键段行为相同，但是比关键段慢。同时意味着可以在不同进程中访问同一个互斥量。

线程ID用来标识当前占有这个互斥量的是系统中哪个线程。递归计数表示这个线程占用该互斥量的次数。互斥量跟事件内核对象一样被经常使用。

下面是互斥量的使用规则：

1：如果线程ID为0，那么该互斥量不为任何线程所占用。处于触发状态。

2：如果线程ID非为0，此时有一个线程已经占有了该互斥量，它处于未触发状态。

使用CreateMutex创建一个互斥量。

bInitialOwner用来控制互斥量的初始状态。如果传入false，那么表示互斥量不属于任何线程。线程ID和递归计数都为0。此时互斥量处于触发状态。

如果为true，互斥量的线程ID将被设为主调线程的线程ID，递归计数被设为1。

OpenMutex来打开一个已存在的互斥量。

为了获得对被保护资源的访问权，线程要调用等待函数并传入互斥量句柄。在内部，等待函数会检查线程ID是否为0，如果为0，等待线程将互斥量对象线程ID设为当前线程ID，递归计数为1。否则，主调线程将会被挂起。当其他线程完成对保护资源的互斥访问，释放对互斥量的占有时，互斥量的线程ID被设为0，原来被挂起的线程变为可调度状态，并将互斥量对象对象ID设为此线程ID，递归计数为1。

前面一直提到递归计数，却没有解释它的意思。当线程试图等待一个未触发的互斥量对象，此时通常处于等待状态。但是系统会检查想要获得互斥量的线程的线程ID与互斥量对象内部记录的线程ID是否相同。如果相同，那么系统会让线程保持可调度状态，即使该互斥量尚未触发。每次线程等待成功一个互斥量，互斥对象的递归计数就会被设为1。因此，使递归对象大于1 的唯一途径是让线程多次等待同一个互斥量。

当目前占有互斥量的线程不再需要访问互斥资源时，它必须调用ReleaseMutex来释放互斥量。

调用ReleaseMutex时该函数会检查调用线程ID是否与互斥量内部保存的线程ID相同。如果相同，那么递归计数会递减。否则函数执行失败返回false。

如果线程成功等待了互斥量对象不止一次，那么线程必须调用相同次数的ReleaseMutex才能使对象的递归计数变成0。

遗弃问题

互斥量具有线程所有权的问题。这就可能导致一些问题：如果占用互斥量的线程在释放互斥量之前终止，对于互斥量来说会发生什么情况呢？答案是：互斥量被遗弃。

系统会检测到互斥量被遗弃的情况，会自动的将互斥量对象的线程ID置为0，然后再检查有没有其他线程等待该互斥量。如果有线程等待，系统会从等待队列中选取一个，将其变为可调度状态。这一切都和原来没什么不同，唯一的区别是等待函数不再返回WAIT_OBJEC_0，而是返回WAIT_ABANDONED。这个特殊的返回值只适用于互斥量。

1. #pragma once
2. typedef struct ELEMENT
3. {
4. DWORD tid;
5. int num;
6. //CMutexAndSemaphoreTestDlg *pDlg;
7. }*PELEMENT;
8. class CQueue
9. {
10. public:
11. CQueue(void);
12. ~CQueue(void);
13. public:
14. bool QueueIn(ELEMENT*p);
15. PELEMENT QueueOut();
16. public:
17. HANDLE m_hSemaphore;
18. HANDLE m_hMutext;
19. HANDLE m_array[2];
20. PELEMENT m_pelement[10];
21. int m_curIndex;
22. };

1. CQueue::CQueue(void)
2. {
3. m_hMutext=CreateMutex(NULL,false,NULL);
4. m_hSemaphore=CreateSemaphore(NULL,0,10,NULL);
5. //m_pelement=new PELEMENT[10];
6. m_curIndex=0;
7. m_array[0]=m_hSemaphore;//先判断同步，再判断互斥。但是书上并没有这样，不知道WaitForMultipleOBjecs会怎样处理？20121230
8. m_array[1]=m_hMutext;
9. //查了下msdn,介绍如下：
10. //When bWaitAll is TRUE, the function's wait operation is completed
11. //       only when the states of all objects have been set to signaled.<span style="color:#ff0000;"> The function does not modify
12. //      the states of the specified objects until the states of all objects have been set to
13. //      signaled.</span> For example, a mutex can be signaled, but the thread does not get ownership
14. //      until the states of the other objects are also set to signaled. In the meantime,
15. //      some other thread may get ownership of the mutex, thereby setting its state to nonsignaled.
16. //
17. }

1. PELEMENT CQueue::QueueOut()
2. {
3. PELEMENT p;
4. p=m_pelement[0];
5. for(int i=0;i<m_curIndex-1;i++)
6. {
7. m_pelement[i]=m_pelement[i+1];
8. }
9. m_curIndex--;
10. ReleaseMutex(m_hMutext);
11. return p;
12. }

1. bool CQueue::QueueIn( ELEMENT*p )
2. {
3. long pp;
4. bool ret=ReleaseSemaphore(m_hSemaphore,1,&pp);
5. if(ret==false)//增加大最大值不再增加。ret返回false.pp返回任一值。
6. {
7. ReaseMutex(m_hMutext);
8. return false;
9. }
10. m_pelement[m_curIndex]=p;
11. m_curIndex++;
12. ReleaseMutex(m_hMutext);
13. return true;
14. }

1. DWORD WINAPI CMutexAndSemaphoreTestDlg::ServerThread( PVOID pparam )
2. {
3. CMutexAndSemaphoreTestDlg *p=(CMutexAndSemaphoreTestDlg*)pparam;
4. while(true)
5. {
6. WaitForMultipleObjects(2,p->queue.m_array,TRUE,INFINITE);
7. InterlockedIncrement(&m);
8. PELEMENT q=p->queue.QueueOut();
9. CString s;
10. s.Format(TEXT("服务线程[%d]第%d次取出产品"),GetCurrentThreadId(),m);
11. p->m_ServerList.InsertString(-1,s);
12. }
13. }
14. DWORD WINAPI CMutexAndSemaphoreTestDlg::ClientThread( PVOID pparam )
15. {
16. //int m=1;
17. CMutexAndSemaphoreTestDlg *p=(CMutexAndSemaphoreTestDlg*)pparam;
18. while(1)
19. {
20. WaitForSingleObject(p->queue.m_hMutext,INFINITE);
21. //WaitForMultipleObjects(2,p->queue.m_array,TRUE,INFINITE);
22. ELEMENT *q=new ELEMENT;
23. q->tid=GetCurrentThreadId();
24. bool ret=p->queue.QueueIn(q);
25. CString s;
26. if(ret)
27. {
28. InterlockedIncrement(&n);
29. s.Format(TEXT("客户线程[%d]第%d次添加!"),q->tid,n);
30. }
31. else
32. {
33. s.Format(TEXT("队列已满！！"));
34. }
35. p->m_ClientList.InsertString(-1,s);
36. Sleep(1000);
37. }
38. return true;
39. }

1. void CMutexAndSemaphoreTestDlg::OnBnClickedOk()
2. {
3. // TODO: 在此添加控件通知处理程序代码
4. m_hClientThread=CreateThread(NULL,0,ClientThread,this,0,NULL);
5. m_hClientThread=CreateThread(NULL,0,ClientThread,this,0,NULL);
6. CreateThreadNULL,0,ClientThread,this,0,NULL);
7. //m_hServerThread=CreateThread(NULL,0,ServerThread,this,0,NULL);
8. m_hServerThread=CreateThread(NULL,0,ServerThread,this,0,NULL);
9. //CDialogEx::OnOK();
10. }