c++线程同步（windows）

Win32中的四种同步方式

在WIN32中，同步机制主要有以下几种：
（1）事件(Event);
（2）信号量(semaphore);
（3）互斥量(mutex);
（4）临界区(Critical section)。

一、临界区

临界区（Critical Section）是一段独占对某些共享资源访问的代码，在任意时刻只允许一个线程对共享资源进行访问。如果有多个线程试图同时访问临界区，那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起，并一直持续到进入临界区的线程离开。临界区在被释放后，其他线程可以继续抢占，并以此达到用原子方式操作共享资源的目的。

临界区在使用时以CRITICAL_SECTION结构对象保护共享资源，并分别用EnterCriticalSection（）和LeaveCriticalSection（）函数去标识和释放一个临界区。所用到的CRITICAL_SECTION结构对象必须经过InitializeCriticalSection（）的初始化后才能使用，而且必须确保所有线程中的任何试图访问此共享资源的代码都处在此临界区的保护之下。否则临界区将不会起到应有的作用，共享资源依然有被破坏的可能。

代码示例：

#include "stdafx.h"

#include<windows.h>

#include<iostream>

using namespace std;

 

int number = 1; //定义全局变量

CRITICAL_SECTION Critical;      //定义临界区句柄

 

unsigned long __stdcall ThreadProc1(void* lp)

{

    while (number < 100)

    {

        EnterCriticalSection(&Critical);

        cout << "thread 1 :"<<number << endl;

        ++number;

        _sleep(100);

        LeaveCriticalSection(&Critical);

    }

 

    return 0;

}

 

unsigned long __stdcall ThreadProc2(void* lp)

{

    while (number < 100)

    {

        EnterCriticalSection(&Critical);

        cout << "thread 2 :"<<number << endl;

        ++number;

        _sleep(100);

        LeaveCriticalSection(&Critical);

    }

 

    return 0;

}

 

int main()

{

    InitializeCriticalSection(&Critical);   //初始化临界区对象

 

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);

    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

 

    Sleep(10*1000);

 

    system("pause");

    return 0;

}

运行结果：

可以看到，也实现了有序输出，实现了线程同步。

二、事件

事件(Event)是WIN32提供的最灵活的线程间同步方式，事件可以处于激发状态(signaled or true)或未激发状态(unsignal or false)。根据状态变迁方式的不同，事件可分为两类：
（1）手动设置：这种对象只可能用程序手动设置，在需要该事件或者事件发生时，采用SetEvent及ResetEvent来进行设置。
（2）自动恢复：一旦事件发生并被处理后，自动恢复到没有事件状态，不需要再次设置。

使用”事件”机制应注意以下事项：
（1）如果跨进程访问事件，必须对事件命名，在对事件命名的时候，要注意不要与系统命名空间中的其它全局命名对象冲突；
（2）事件是否要自动恢复；
（3）事件的初始状态设置。

由于event对象属于内核对象，故进程B可以调用OpenEvent函数通过对象的名字获得进程A中event对象的句柄，然后将这个句柄用于ResetEvent、SetEvent和WaitForMultipleObjects等函数中。此法可以实现一个进程的线程控制另一进程中线程的运行，例如：

HANDLE hEvent=OpenEvent(EVENT_ALL_ACCESS,true,"MyEvent");

ResetEvent(hEvent);

代码示例：

#include "stdafx.h"

#include<windows.h>

#include<iostream>

using namespace std;

 

int number = 1; //定义全局变量

HANDLE hEvent;  //定义事件句柄

 

unsigned long __stdcall ThreadProc1(void* lp)

{

    while (number < 100)

    {

        WaitForSingleObject(hEvent, INFINITE);  //等待对象为有信号状态

        cout << "thread 1 :"<<number << endl;

        ++number;

        _sleep(100);

        SetEvent(hEvent);

    }

 

    return 0;

}

 

unsigned long __stdcall ThreadProc2(void* lp)

{

    while (number < 100)

    {

        WaitForSingleObject(hEvent, INFINITE);  //等待对象为有信号状态

        cout << "thread 2 :"<<number << endl;

        ++number;

        _sleep(100);

        SetEvent(hEvent);

    }

 

    return 0;

}

 

int main()

{

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);

    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

    hEvent = CreateEvent(NULL, FALSE, TRUE, "event");

 

    Sleep(10*1000);

 

    system("pause");

    return 0;

}

运行结果：

可以看到，实现了有序输出，实现了线程同步。

三、信号量

信号量是维护0到指定最大值之间的同步对象。信号量状态在其计数大于0时是有信号的，而其计数是0时是无信号的。信号量对象在控制上可以支持有限数量共享资源的访问。

信号量的特点和用途可用下列几句话定义：
（1）如果当前资源的数量大于0，则信号量有效；
（2）如果当前资源数量是0，则信号量无效；
（3）系统决不允许当前资源的数量为负值；
（4）当前资源数量决不能大于最大资源数量。

创建信号量

函数原型为：

HANDLE CreateSemaphore (

  　PSECURITY_ATTRIBUTE psa, //信号量的安全属性

　  LONG lInitialCount, //开始时可供使用的资源数

　  LONG lMaximumCount, //最大资源数

   PCTSTR pszName);     //信号量的名称

释放信号量

通过调用ReleaseSemaphore函数，线程就能够对信标的当前资源数量进行递增，该函数原型为：

BOOL WINAPI ReleaseSemaphore(

  　HANDLE hSemaphore,   //要增加的信号量句柄

  　LONG lReleaseCount, //信号量的当前资源数增加lReleaseCount

  　LPLONG lpPreviousCount  //增加前的数值返回

   );

打开信号量　

和其他核心对象一样，信号量也可以通过名字跨进程访问，打开信号量的API为：

HANDLE OpenSemaphore (

  　DWORD fdwAccess,      //access

  　BOOL bInherithandle,  //如果允许子进程继承句柄，则设为TRUE

  　PCTSTR pszName  //指定要打开的对象的名字

  );

代码示例：

#include "stdafx.h"

#include<windows.h>

#include<iostream>

using namespace std;

 

int number = 1; //定义全局变量

HANDLE hSemaphore;  //定义信号量句柄

 

unsigned long __stdcall ThreadProc1(void* lp)

{

    long count;

    while (number < 100)

    {

        WaitForSingleObject(hSemaphore, INFINITE);  //等待信号量为有信号状态

        cout << "thread 1 :"<<number << endl;

        ++number;

        _sleep(100);

        ReleaseSemaphore(hSemaphore, 1, &count);

    }

 

    return 0;

}

 

unsigned long __stdcall ThreadProc2(void* lp)

{

    long count;

    while (number < 100)

    {

        WaitForSingleObject(hSemaphore, INFINITE);  //等待信号量为有信号状态

        cout << "thread 2 :"<<number << endl;

        ++number;

        _sleep(100);

        ReleaseSemaphore(hSemaphore, 1, &count);

    }

 

    return 0;

}

 

int main()

{

    hSemaphore = CreateSemaphore(NULL, 1, 100, "sema");

 

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);

    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

 

    Sleep(10*1000);

 

    system("pause");

    return 0;

}

　　

运行结果：

可以看到，实现了有序输出，实现了线程间同步。

四、互斥量

采用互斥对象机制。 只有拥有互斥对象的线程才有访问公共资源的权限，因为互斥对象只有一个，所以能保证公共资源不会同时被多个线程访问。互斥不仅能实现同一应用程序的公共资源安全共享，还能实现不同应用程序的公共资源安全共享。

代码示例：

#include "stdafx.h"

#include<windows.h>

#include<iostream>

using namespace std;

 

int number = 1; //定义全局变量

HANDLE hMutex;  //定义互斥对象句柄

 

unsigned long __stdcall ThreadProc1(void* lp)

{

    while (number < 100)

    {

        WaitForSingleObject(hMutex, INFINITE);

        cout << "thread 1 :"<<number << endl;

        ++number;

        _sleep(100);

        ReleaseMutex(hMutex);

    }

 

    return 0;

}

 

unsigned long __stdcall ThreadProc2(void* lp)

{

    while (number < 100)

    {

        WaitForSingleObject(hMutex, INFINITE);

        cout << "thread 2 :"<<number << endl;

        ++number;

        _sleep(100);

        ReleaseMutex(hMutex);

    }

 

    return 0;

}

 

int main()

{

    hMutex = CreateMutex(NULL, false, "mutex");     //创建互斥对象

 

    CreateThread(NULL, 0, ThreadProc1, NULL, 0, NULL);

    CreateThread(NULL, 0, ThreadProc2, NULL, 0, NULL);

 

    Sleep(10*1000);

 

    system("pause");

    return 0;

}

运行结果：

可以看到，实现了有序输出，实现了线程同步。

全局变量

因为进程中的所有线程均可以访问所有的全局变量，因而全局变量成为Win32多线程通信的最简单方式。