孙鑫VC视频教程笔记之第十六课(上)“线程同步”

线程同步有三种方式：

1.      互斥对象涉及方法：

HANDLE hMutex=CreateMutex(NULL,FALSE,NULL); //第二个参数为FALSE,将互斥对象声明为空闲状态

WaitForSingleObject(hMutex,INFINITE); //第二个参数为INFINITE表示一直等待，直到拥有互斥对象

ReleaseMutex(hMutex); //使用完了，将互斥对象还给操作系统

      具体代码及各种情况的分析见上一章，这里就不再叙述。

 

2.      事件对象：

事件对象也属于内核对象，包含一个使用计数，一个用于指明该事件是一个自动重置的事件还是一个人工重置的事件的布尔值，另一个用于指明该事件处于可用状态还是不可用的布尔值。

有两种不同类型的事件对象。一种是人工重置的事件，另一种是自动重置的事件。当人工重置的事件得到通知时，等待该事件的所有线程均变为可调度线程。当一个自动重置的事件得到通知时，等待该事件的线程中只有一个线程变为可调度线程。所以优先选择自动重置的事件。

 

说明：CreateEvent方法第一个参数是关于的安全的结构体，一般设置为NULL；第二个参数表示是人工重置还是自动重置，TRUE代表人工重置；第三个参数表示当前状态是可用还是不可用；第四个参数表示Event名称，NULL的话，默认。

HANDLE g_hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);

以下代码会出现异常：在将CreateEvent的第二个参数设置为人工重置的时候，因为等待该事件的所有线程均变为可调度线程，所以发现售票实例程序最终会出现0。所以最好还是选择自动重置的事件。

#include <windows.h>

#include <iostream.h>

 

DWORD WINAPI ThreadProc1(LPVOID lpParameter);

DWORD WINAPI ThreadProc2(LPVOID lpParameter);

 

int ticket=100;

HANDLE g_hEvent;

 

void main()

{

      HANDLE handle1=CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);

      HANDLE handle2=CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);

      CloseHandle(handle1);

      CloseHandle(handle2);

     

      g_hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);

 

      Sleep(4000);

      CloseHandle(g_hEvent);

}

 

DWORD WINAPI ThreadProc1(LPVOID lpParameter)

{

      while(TRUE)

      {

           WaitForSingleObject(g_hEvent,INFINITE); //第二个参数为INFINITE表示一直等待，直到拥有互斥对象

           if(ticket>0)

           {

                 Sleep(1);

                 cout<<"thread1 sale the ticket id is:"<<ticket--<<endl;

           }

           else

                 break;

      }

      return 0;

}

 

DWORD WINAPI ThreadProc2(LPVOID lpParameter)

{

      while(TRUE)

      {

           WaitForSingleObject(g_hEvent,INFINITE);

           if(ticket>0)

           {

                 Sleep(1);

                 cout<<"thread2 sale the ticket id is:"<<ticket--<<endl;

           }

           else

                 break;

      }

      return 0;

}

 

 

说明：

如果一个线程循环内部已经调用了WaitForSingleObject(g_hEvent,INFINITE);但是在单个循环完成前没有调用SetEvent(g_hEvent)将状态设置成可用的话，下一次进入循环时再次调用WaitForSingleObject时发现状态不可用，所以一直等待，代码例子将上面的代码g_hEvent=CreateEvent(NULL,TRUE,TRUE,NULL);修改为g_hEvent=CreateEvent(NULL,FALSE,TRUE,NULL);则会出现这个问题，其结果就是仅仅线程1售出了100这张票。如果在循环退出前调用SetEvent(g_hEvent);则问题可以解决。

 

综上所述，涉及到的方法：

HANDLE g_hEvent=CreateEvent(NULL,TRUE,FALSE,NULL);

WaitForSingleObject(g_hEvent,INFINITE); //等待事件，如果事件可用，运行下面的代码，并且将事件状态设置为不可用状态，如果事件不可用，一直等待。

SetEvent(g_hEvent)  //将事件设置为可用的状态

ResetEvent(g_hEvent) //将事件设置为不可用状态

一般情况下WaitForSingleObject和SetEvent配对使用。

 

3.      关键代码段：

关键代码段(临界区)是指一个小代码段，在代码能够执行前，它必须独占对某些资源的访问权。

            可以将关键代码段想象成电话亭资源：

           CRITICAL_SECTION g_cs;

           InitializeCriticalSection(&g_cs); //创建电话亭资源，一般放在构造函数中

           EnterCriticalSection(&g_cs); //判断关键资源所有权是否可用，可用则进入

           LeaveCriticalSection(&g_cs）；使用完关键资源后，释放所有权

           DeleteCriticalSection(&g_cs); //销毁电话亭资源，一般放在析构函数中

      其中InitializeCriticalSection和DeleteCriticalSection配对使用；

      EnterCriticalSection和LeaveCriticalSection配对使用，中间存放访问共享资源的代码。

 

4.      互斥对象、事件对象与关键代码段的比较

互斥对象和事件对象属于内核对象，利用内核对象进行线程同步，速度较慢，但利用互斥对象和事件对象这样的内核对象，可以在多个进程中的各个线程间进行同步。

关键代码段是工作在用户方式下，同步速度较快，但在使用关键代码段时，很容易进入死锁状态，因为在等待进入关键代码段时无法设定超时值。

 

5.      死锁：

哲学家进餐的问题：每个哲学家手中只有一根筷子，要进餐必须有两根，但谁也不愿意先给出自己的那根给别人。大家都处于等待状态。

线程1拥有了临界区对象A，等待临界区对象B的拥有权，线程2拥有了临界区对象B，等待临界区对象A的拥有权，就造成了死锁。

死锁代码：

#include <windows.h>

#include <iostream.h>

 

DWORD WINAPI ThreadProc1(LPVOID lpParameter);

DWORD WINAPI ThreadProc2(LPVOID lpParameter);

 

int ticket=100;

 

//创建两个关键资源

CRITICAL_SECTION g_cs1;

CRITICAL_SECTION g_cs2;

 

void main()

{

      HANDLE handle1=CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);

      HANDLE handle2=CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);

      CloseHandle(handle1);

      CloseHandle(handle2);

     

      InitializeCriticalSection(&g_cs1);

      InitializeCriticalSection(&g_cs2);

 

      Sleep(4000);

      DeleteCriticalSection(&g_cs1);

      DeleteCriticalSection(&g_cs2);

}

 

DWORD WINAPI ThreadProc1(LPVOID lpParameter)

{

      while(TRUE)

      {

           EnterCriticalSection(&g_cs1);

           Sleep(1);

           EnterCriticalSection(&g_cs2);

           if(ticket>0)

           {

                 Sleep(1);

                 cout<<"thread1 sale the ticket id is:"<<ticket--<<endl;

           }

           else

                 break;

           LeaveCriticalSection(&g_cs1);

           LeaveCriticalSection(&g_cs2);

      }

      return 0;

}

 

DWORD WINAPI ThreadProc2(LPVOID lpParameter)

{

      while(TRUE)

      {

           EnterCriticalSection(&g_cs2);

           Sleep(1);

           EnterCriticalSection(&g_cs1);

           if(ticket>0)

           {

                 Sleep(1);

                 cout<<"thread2 sale the ticket id is:"<<ticket--<<endl;

           }

           else

                 break;

           LeaveCriticalSection(&g_cs1);

           LeaveCriticalSection(&g_cs2);

      }

      return 0;

}

 

说明：首先线程1得到资源1的所有权，然后睡眠1毫秒，线程1就让出了执行权，这个时候线程2得到执行权，运行，得到资源2的所有权，线程2然后睡眠1毫秒，线程2就让出了执行权，这个时候线程1得到执行权，线程1继续执行，想得到资源2的资源，但发现资源2被线程1所占用，等待。当线程1的事件片过了以后，线程2得到执行权，继续执行，想得到资源1的所有权，但发现资源1被线程1占用，所以也继续等待，这样线程1和线程2都互相等待，造成死锁。