C++线程同步 -- windows

简介：

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

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

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

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

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

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

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

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

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

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

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

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

 1 #include <Windows.h>
 2 #include <iostream>
 3
 4 using namespace std;
 5
 6 int number = 1;
 7
 8 unsigned long __stdcall ThreadProc1(void* lp)
 9 {
10     while(number < 100)
11     {
12         cout << "thread 1: " << number << endl;
13         ++number;
14         _sleep(100);
15     }
16     return 0;
17 }
18
19 unsigned long __stdcall ThreadProc2(void* lp)
20 {
21     while(number < 100)
22     {
23         cout << "thread 1: " << number << endl;
24         ++number;
25         _sleep(100);
26     }
27     return 0;
28 }
29
30 int main()
31 {
32     CreateThread(NULL,0,ThreadProc1,NULL,0,NULL);
33     CreateThread(NULL,0,ThreadProc2,NULL,0,NULL);
34
35     Sleep(10*1000);
36
37     system("pause");
38     return 0;
39 }

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

在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 = 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<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;
}

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

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

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

#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;
}

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

#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, L"event");  //

    Sleep(10*1000);

    system("pause");
    return 0;
}

原文地址：https://www.cnblogs.com/wzqstudy/p/12093158.html

时间： 2024-10-31 00:12:32

C++线程同步 -- windows的相关文章

线程同步(windows平台)：互斥对象

一:介绍 互斥对象是系统内核维护的一种数据结构,保证了对象对单个线程的访问权. 二:函数说明 创建互斥对象:    HANDLE CreateMutex(            LPSECURITY_ATTRIBUTES lpMutexAttributes, 安全属性结构指针,可为NULL,表示默认安全性            BOOL bInitialOwner,     //是否占有该互斥量,TRUE:占有,FALSE:不占有            LPCTSTR lpName       

线程同步(windows平台)：事件

一:介绍 事件Event实际上是个内核对象,事件分两种状态:激发状态和未激发状态.分两种类型:手动处置事件和自动处置事件.手动处置事件被设置为激发状态后,会唤醒所有等待的线程,一直保持为激发状态,直到把它设置为未激发状态.自动处置事件被设置为激发状态后,会唤醒一个等待中的线程,然后会自动设置成未激发状态. 二:函数说明 创建事件对象:    HANDLE CreateEvent    (     LPSECURITY_ATTRIBUTES lpEventAttributes, // 安全属性  

线程同步(windows平台)：信号量

一:介绍 信号量也是系统核心对象,它允许多个线程同一时刻访问同一资源,但需限制同一时刻访问资源的最大线程数目. 信号量遵循规则:1.当前资源计数大于0,信号量有效.2.当前资源计数等于0,信号量无效.3.系统不允许当前资源数量为负.4.当前资源数量不能大于最大资源数量. 二:函数说明 创建信号量:    HANDLE   CreateSemaphore(         LPSECURITY ATTRIBUTES   lpSemaphoreAttributes,     //安全属性      

Windows线程同步总结

Windows线程同步 Windows的线程同步可以利用互斥对象来实现,也可以使用事件对象,关键代码段来实现. 1 事件对象实现线程同步 <1>Event对象创建函数 事件对象的创建事件对象属于内核对象,它包含以三个成员:使用计数,是否是自动重置还是人工重置的布尔值,通知状态的布尔值. HANDLE CreateEvent( LPSECURITY_ATTRIBUTESlpEventAttributes, BOOLbManualReset, BOOLbInitialState, LPCSTRlp

Windows线程同步（未完）

先介绍一个创建线程的API,参考:https://msdn.microsoft.com/en-us/library/windows/desktop/ms682453%28v=vs.85%29.aspx Creates a thread to execute within the virtual address space of the calling process. HANDLE WINAPI CreateThread( _In_opt_ LPSECURITY_ATTRIBUTES lpThr

windows下使用Critical Section和Mutex实现线程同步实例

利用critical section 和 Mutex两种不同的线程同步的方法实现生产者消费者问题.生产者线程要能够对一个计数器进行增的操作,并且将其输出在控制台上,消费者线程能够对这个计数器进行减的操作,并将其输出在控制台上.两种线程都共享一个计数器. 其中增.减计数器的数我设置为1-6随机. 测试两种方法的对比,用网上整理出的一张表如下 1.使用CriticalSection 方法时,有一个临界区cs 在将临界区传递给 InitializeCriticalSection 时(或者更准确地说,是

Windows核心编程笔记（7）----内核模式下的线程同步

1.内核对象同步与用户模式下同步对比 使用内核对象的唯一缺点就是性能,调用内核对象函数时,调用线程必须从用户模式切换到内核模式,这种切换是相当 耗时的. 内核对象(进程.线程.作业)要么处于触发态,要么处于未触发状态.进程内核对象在创建时总是处于未触发状态, 当进程终止时,操作系统会自动使进程内核对象变成触发状态.当进程内核对象处于触发状态后,将永远保持这种状态, 再也不能变回未触发状态. 2.等待内核对象 WaitForSingleObject等待单个内核对象,WaitForMultipleO

Windows线程同步

说到windows线程同步的方法,有循环锁,临界区(关键代码段),内核对象(Event,Semaphore,Mutex).甚至进程,线程handle等等. 说说用法: 临界区和mutex都可以用于控制共享资源的互斥访问,不同点是 临界区是用户级对象,消耗小,速度快,但是不能跨进程.mutex是内核对象速度慢,但是可以跨进程. semaphore可以用来进行资源控制,信号量的两个关键参数,现有资源数和最大资源数,可以用于对资源的控制,通过ReleaseSemaphore对资源增加,WaitFor*

windows 线程同步学习测试-1

环境win7旗舰64位系统,vs2013,AMD fx™4100 Auad-core processor ,8G内存, 看<windows核心编程>线程同步一章,看到有说g_x++会不同步的问题,试着写些代码加深印象.发现+1太快了,看不出效果,于是for循环了1亿次.代码如下: #include "stdafx.h" using std::cout; using std::endl; using std::cin; unsigned __stdcall ThreadFun