C++线程同步 -- windows

简介：

　　在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，

由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就要使线程同步。

　　同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。

　　“同”字从字面上容易理解为一起动作 ， 其实不是，“同”字应是指协同、协助、互相配合。

　　如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。

　　在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行了解。

正常情况下对这种处理结果的了解应当在其处理任务完成后进行。

　　如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误了解。例如，多个线程同时访问同一个全局变量，

如果都是读取操作，则不会出现问题。如果一个线程负责改变此变量的值，而其他线程负责同时读取变量内容，则不能保证读取到的数据是经过写线程修改后的。

　　为了确保读线程读取到的是经过修改的变量，就必须在向变量写入数据时禁止其他线程对其的任何访问，直至赋值过程结束后再解除对其他线程的访问限制。

这种保证线程能了解其他线程任务处理结束后的处理结果而采取的保护措施即为线程同步。

 

　　下面实例演示了两个线程同时对一个局部变量进行加操作，多线程资源访问冲突的情况。

 #include <Windows.h>
 #include <iostream>

 using namespace std;

 int number = ;

 unsigned long __stdcall ThreadProc1(void* lp)
 {
     while(number < )
     {
         cout << "thread 1: " << number << endl;
         ++number;
         _sleep();
     }
     return ;
 }

 unsigned long __stdcall ThreadProc2(void* lp)
 {
     while(number < )
     {
         cout << "thread 1: " << number << endl;
         ++number;
         _sleep();
     }
     return ;
 }

 int main()
 {
     CreateThread(NULL,,ThreadProc1,NULL,,NULL);
     CreateThread(NULL,,ThreadProc2,NULL,,NULL);

     Sleep(*);

     system("pause");
     return ;
 }

可以看到有时两个线程计算的值相同，不是我们想要的结果。

 

在WIN32中，同步机制主要有以下几种：

（1）信号量(semaphore);

（2）互斥量(mutex);
（3）临界区(Critical section)

（4）事件(Event);

 

-------------------------------------信号量----------------------------------------------------

 

信号量是维护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<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
HANDLE hSemaphore;  //定义信号量句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    long count;
    while (number < )
    {
        WaitForSingleObject(hSemaphore, INFINITE);  //等待信号量为有信号状态
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseSemaphore(hSemaphore, , &count);
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    long count;
    while (number < )
    {
        WaitForSingleObject(hSemaphore, INFINITE);  //等待信号量为有信号状态
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseSemaphore(hSemaphore, , &count);
    }

    return ;
}

int main()
{
    hSemaphore = CreateSemaphore(NULL, , , "sema");

    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);

    Sleep(*);

    system("pause");
    return ;
}

-------------------------------------互斥量----------------------------------------------------

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

#include<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
HANDLE hMutex;  //定义互斥对象句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseMutex(hMutex);
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        ReleaseMutex(hMutex);
    }

    return ;
}

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

    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);

    Sleep(*);

    system("pause");
    return ;
}

-------------------------------------临界区----------------------------------------------------

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

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

#include<windows.h>
#include<iostream>
using namespace std;

int number = ; //定义全局变量
CRITICAL_SECTION Critical;      //定义临界区句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < )
    {
        EnterCriticalSection(&Critical);
        cout << "thread 1 :"<<number << endl;
        ++number;
        _sleep();
        LeaveCriticalSection(&Critical);
    }

    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < )
    {
        EnterCriticalSection(&Critical);
        cout << "thread 2 :"<<number << endl;
        ++number;
        _sleep();
        LeaveCriticalSection(&Critical);
    }

    return ;
}

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

    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);

    Sleep(*);

    system("pause");
    return ;
}

 

-------------------------------------事件-实例------------------------------------------------

#include <Windows.h>
#include <iostream>

using namespace std;

int number = ;    //定义全局变量
HANDLE hEvent; //定义事件句柄

unsigned long __stdcall ThreadProc1(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hEvent,INFINITE);
        cout << "Thread 1 :" << number << endl;
        ++number;
        _sleep();
        SetEvent(hEvent);
    }
    return ;
}

unsigned long __stdcall ThreadProc2(void* lp)
{
    while (number < )
    {
        WaitForSingleObject(hEvent,INFINITE);
        cout << "Thread 2 :" << number << endl;
        ++number;
        _sleep();
        SetEvent(hEvent);
    }
    return ;
}

int main()
{
    CreateThread(NULL, , ThreadProc1, NULL, , NULL);
    CreateThread(NULL, , ThreadProc2, NULL, , NULL);
    hEvent = CreateEvent(NULL, FALSE, TRUE, L"event");  //

    Sleep(*);

    system("pause");
    return ;
}