Windows下C++多线程同步与互斥简单运用

最新推荐文章于 2024-09-17 11:05:37 发布
最新推荐文章于 2024-09-17 11:05:37 发布
阅读量437 收藏
点赞数
分类专栏： C++ 文章标签： windows 多线程 同步与互斥
  1. 互斥量，Mutex
#include < Windows.h>  
#include <iostream>  
using namespace std;  
DWORD WINAPI Thread1(LPVOID lpParmeter);  
DWORD WINAPI Thread2(LPVOID lpParmeter);  
static HANDLE g_hMutex = INVALID_HANDLE_VALUE;  
static int g_iCnt = 100;  
int main()  
{  
    HANDLE hThread1 = INVALID_HANDLE_VALUE;  
    HANDLE hThread2 = INVALID_HANDLE_VALUE;  
    g_hMutex = CreateMutex(NULL, FALSE, "Mutex");  
    // 第二个参数：创建者是否拥有所有权，FALSE为没有所有权，  
    // 遇到第一个WaitForSingleObject的时候就把所有权给它，  
    // 所以Thread1里面的WaitForSingleObject(g_hMutex, INFINITE)能够继续执行  
    if (!g_hMutex)  
    {  
        cout << "Failed to CreateMutex !" << endl;  
        return 0;  
    }  
    hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
    hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
    Sleep(4000);        // 让2个线程有足够的时间执行完操作。  
    CloseHandle(hThread1);  
    CloseHandle(hThread2);  
    system("PAUSE");  
    return 0;  
}  
DWORD WINAPI Thread1(LPVOID lpParmeter)  
{  
    while (true)  
    {  
        // 请求事件对象  
        WaitForSingleObject(g_hMutex, INFINITE);    // INFINITE: 长时间等待，差不多50天左右吧！  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "Thread1:" << g_iCnt-- << endl;  
            ReleaseMutex(g_hMutex);                 // 释放资源  
        }  
        else  
        {  
            ReleaseMutex(g_hMutex);  
            break;  
        }  
    }  
    return 0;  
}  
DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
{  
    while (true)  
    {  
        // 请求事件对象  
        WaitForSingleObject(g_hMutex,INFINITE);  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "thread2:" << g_iCnt-- << endl;  
            ReleaseMutex(g_hMutex);  
        }  
        else  
        {  
            ReleaseMutex(g_hMutex);  
            break;  
        }  
    }  
    return 0;  
}

几个注意的地方：

(1)互斥量为内核对象，能够与其他线程或特殊事件取得同步；

(2)速度比临界区要慢；

(3)互斥量对象与所有其它内核对象的不同之处在于它是被线程所拥有的，互斥量对象除了记录当前信号状态外，还要记住此时那个线程拥有它。

(4)这个常来被运用于限制程序启动次数！

2.事件 Event

#include <Windows.h>  
#include <iostream>  
using namespace std;  
DWORD WINAPI Thread1(LPVOID lpParmeter);  
DWORD WINAPI Thread2(LPVOID lpParmeter);  
static HANDLE g_hEvent = INVALID_HANDLE_VALUE;  
static int g_iCnt = 100;  
int main()  
{  
    HANDLE hThread1 = INVALID_HANDLE_VALUE;  
    HANDLE hThread2 = INVALID_HANDLE_VALUE;  
    g_hEvent = CreateEvent(NULL, false, false, "Event");  
    if (!g_hEvent)  
    {  
        cout << "Failed to CreateEvent !" << endl;  
        return 0;  
    }  
    /*HANDLE CreateEvent( 
    LPSECURITY_ATTRIBUTES lpEventAttributes,    // SECURITY_ATTRIBUTES结构指针，可为NULL 
    BOOL bManualReset,  // 手动/自动 
                        // TRUE： 在WaitForSingleObject后必须手动调用ResetEvent清除信号  
                        // FALSE：在WaitForSingleObject后，系统自动清除事件信号 
    BOOL bInitialState,                         // 初始状态 
    LPCTSTR lpName                              // 事件的名称 
    );*/  
    hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
    hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
    SetEvent(g_hEvent);  
    Sleep(4000);        // 让2个线程有足够的时间执行完操作。  
    CloseHandle(hThread1);  
    CloseHandle(hThread2);  
    system("PAUSE");  
    return 0;  
}  
DWORD WINAPI Thread1(LPVOID lpParmeter)  
{  
    while (true)  
    {  
        // 请求事件对象  
        WaitForSingleObject(g_hEvent, INFINITE);    // INFINITE: 长时间等待，差不多50天左右吧！  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "Thread1:" << g_iCnt-- << endl;  
            SetEvent(g_hEvent);  
        }  
        else  
        {  
            SetEvent(g_hEvent);  
            break;  
        }  
    }  
    return 0;  
}  
DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
{  
    while (true)  
    {  
        // 请求事件对象  
        WaitForSingleObject(g_hEvent,INFINITE);  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "thread2:" << g_iCnt-- << endl;  
            SetEvent(g_hEvent);  
        }  
        else  
        {  
            SetEvent(g_hEvent);  
            break;  
        }  
    }  
    return 0;  
}

几个注意的地方：

(1).和Mutex使用差不多，只有细微的差别；

(2).可以使用SetEvent或ResetEvent改变其状态；

(3).在应用程序中任意一处没有正确的按照规则调用SetEvent或ResetEvent，将达不到同步或互斥的目的;

(4).一般来说，都是利用Event来进行同步，而不是我们这里的让它来达到互斥;

(5).Event处于无信号状态时，相关线程或进程退出，系统并不会尝试将其置为有信号状态;

3.临界区 CRITICAL_SECTION

#include <Windows.h>  
#include <iostream>  
using namespace std;  
DWORD WINAPI Thread1(LPVOID lpParmeter);  
DWORD WINAPI Thread2(LPVOID lpParmeter);  
CRITICAL_SECTION g_CriticalSection; // 定义  
static int g_iCnt = 100;  
int main()  
{  
    HANDLE hThread1 = INVALID_HANDLE_VALUE;  
    HANDLE hThread2 = INVALID_HANDLE_VALUE;  
    InitializeCriticalSection(&g_CriticalSection);      // 初始化  
    hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
    hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
    Sleep(4000);        // 让2个线程有足够的时间执行完操作。  
    CloseHandle(hThread1);  
    CloseHandle(hThread2);  
    DeleteCriticalSection(&g_CriticalSection);          // 删除  
    system("PAUSE");  
    return 0;  
}  
DWORD WINAPI Thread1(LPVOID lpParmeter)  
{  
    while (true)  
    {  
        EnterCriticalSection(&g_CriticalSection);       // 进入临界区，获得所有权，其他线程就等待  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "Thread1:" << g_iCnt-- << endl;  
            LeaveCriticalSection(&g_CriticalSection);   // 离开临界区，释放所有权  
        }  
        else  
        {  
            LeaveCriticalSection(&g_CriticalSection);  
            break;  
        }  
    }  
    return 0;  
}  
DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
{  
    while (true)  
    {  
        EnterCriticalSection(&g_CriticalSection);  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "thread2:" << g_iCnt-- << endl;  
            LeaveCriticalSection(&g_CriticalSection);  
        }  
        else  
        {  
            LeaveCriticalSection(&g_CriticalSection);  
            break;  
        }  
    }  
    return 0;  
}

几个注意的地方：

(1).比Mutex速度快；

(2).临界区在线程内的分配必须是全局的；

(3). 临界区一次只允许一个线程访问;

4.信号量Semaphore

首先说说那些关于信号量那些不得不让人伤心的事情，因为笔者大学不好学习，非常调皮，而信号量又是老师最讨论及考试的话题之一，所以我觉得这个东西非常扯淡，非常影响情绪，于是放在最后。------以上是为题外话。

为什么大学老师总是喜欢信号量呢？

因为这是一个生产者-消费者模型，并且很多计算机问题都可以看做是生产者-消费者的问题，是同步最易理解的模型。

关于理论上的知识，我就不说了，书里面很多的。

还有我不是很想实现生产者-消费者的模型，就用其他例子代替了。这个有点不负责任。

#include <Windows.h>  
#include <iostream>  
#include <vector>  
using namespace std;  
DWORD WINAPI Thread1(LPVOID lpParmeter);  
DWORD WINAPI Thread2(LPVOID lpParmeter);  
static HANDLE g_hSemaphore = INVALID_HANDLE_VALUE;; // 定义  
static int g_iCnt = 100;  
int main()  
{  
    HANDLE hThread1 = INVALID_HANDLE_VALUE;  
    HANDLE hThread2 = INVALID_HANDLE_VALUE;  
    // HANDLE CreateSemaphore (  
    //  PSECURITY_ATTRIBUTE psa,  
    //  LONG lInitialCount, //开始时可供使用的资源数  
    //  LONG lMaximumCount, //最大资源数  
    //  PCTSTR pszName);  
    g_hSemaphore = CreateSemaphore(NULL, 1, 1, "Semaphore");          
    // 初始化有1个信号量。  
    if (g_hSemaphore == INVALID_HANDLE_VALUE)  
    {  
        cout << "Failed to Create Semaphore!" << endl;  
        return 0;  
    }  
    hThread1 = CreateThread(NULL, 0, Thread1, NULL, 0, NULL);  
    hThread2 = CreateThread(NULL, 0, Thread2, NULL, 0, NULL);  
    Sleep(4000);        // 让2个线程有足够的时间执行完操作。  
    CloseHandle(hThread1);  
    CloseHandle(hThread2);  
    system("PAUSE");  
    return 0;  
}  
DWORD WINAPI Thread1(LPVOID lpParmeter)  
{  
    while (true)  
    {  
        WaitForSingleObject(g_hSemaphore, INFINITE);        // 释放一个信号量  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "Thread1:" << g_iCnt-- << endl;  
            ReleaseSemaphore(g_hSemaphore, 1, NULL);        // 增加一个信号量  
        }  
        else  
        {  
            break;  
        }  
    }  
    return 0;  
}  
DWORD WINAPI Thread2(LPVOID lpParameter)//thread data  
{  
    while (true)  
    {  
        WaitForSingleObject(g_hSemaphore, INFINITE);  
        if (g_iCnt > 0)  
        {  
            Sleep(20);  
            cout << "thread2:" << g_iCnt-- << endl;  
            ReleaseSemaphore(g_hSemaphore, 1, NULL);  
        }  
        else  
        {  
            break;  
        }  
    }  
    return 0;  
}

几个注意的地方：

信号量内核对象对线程的同步方式与前面几种不同，它允许多个线程在同一时刻访问某一资源，但是需要限制同一时刻访问此资源的最大线程数目。

总结： 线程规模 = CPU 数 * 2 + 1

代码搬运工007
关注
专栏目录
【3】c++多线程技术之线程同步与互斥
以道御术
04-12 402
线程安全问题与数据竞争是多线程编程中的重要概念。在C++中，线程安全问题主要涉及到多个线程对共享数据的访问，如果多个线程同时访问同一块内存区域，并且至少有一个线程对该区域进行写入操作，那么就可能发生数据竞争（Data Race）。数据竞争可能导致程序行为不可预测，甚至可能引发严重的错误。为了避免数据竞争，我们需要使用一些同步机制，如互斥锁（Mutex）和条件变量（Condition Variable）等。下面是一个简单的例子，展示了如何使用C++的std::mutex。
【并发编程九】c++线程同步——互斥（mutex）
junxuezheng的博客
01-03 1645
简介：本篇文章，我们详细的介绍下c++标准库提供的线程同步方法中的第一个——互斥（mutex）。
Windows多线程的同步与互斥
luxiaoxun的专栏
06-06 3984
系统中的所有线程都必须拥有对各种系统资源的访问权，这些资源包括内存堆栈，串口，文件，窗口和许多其他资源。如果一个线程需要独占对资源的访问权，那么其他线程就无法完成它们的工作。反过来说，也不能让任何一个线程在任何时间都能访问所有的资源。如果在一个线程从内存块中读取数据时，另一个线程却想要将数据写入同一个内存块，那么这就像你在读一本书时另一个人却在修改书中的内容一样。这样，书中的内容就会被搞得乱七八糟
C++线程同步与互斥总结
weixin_30650859的博客
07-05 113
互斥：当多个线程访问同一个全局变量，或者同一个资源(比如打印机)的时候，需要进行线程间的互斥操作来保证访问的安全性。 临界区、互斥体、事件和信号量都可以实现线程互斥.但如果仅仅需要实现互斥功能，推荐前两种。 两者的区别：1、临界区只能用于进程内的线程互斥，性能较好。 ...
C++ 多线程之间的通信方式(windows下实现)
热门推荐
lizhenwei0219的博客
07-18 2万+
最近学习了C++ 多线程之间的通信方式,记录一下。 参考原文:https://blog.csdn.net/eulb/article/details/2177500 C++线程的通信方式有很多种,这里记录一下常用的几种: 1.全局变量 2.互斥量 3.信号量 4.事件 5.临界区 1.全局变量 通过全局变量进行通信,要对该变量加关键字volatile volatile(易变的):每...
windows线程同步与互斥
new9232的博客
08-13 1182
windows线程同步与互斥。临界区对象，事件内核对象，互斥量，信号量
c++ 多线程向同一个文本写入信息 解决同步与互斥问题
12-23
c++ 多线程向同一个文本写入信息 解决同步与互斥问题
linux上实现多进程和多线程实现同步互斥（源代码）
04-18
总结，Linux上的多进程和多线程编程涉及复杂的同步互斥操作，开发者需要理解各种同步机制，根据具体需求选择合适的方法。通过阅读和学习提供的源代码，可以加深对这些概念的理解，提升实际开发能力。
使用临界区来实现多线程的同步互斥.critical section
03-28
本篇文章将深入探讨临界区的概念、如何在C++中实现多线程的同步互斥，并结合提供的文件名，推测可能的项目结构。 临界区是指一段必须被互斥执行的代码，即同一时刻只有一个线程可以执行这段代码。为了实现这一目标...
windows C/C++ 线程安全（三）（互斥+同步）
网瘾少年丶的博客
05-20 585
承接上一篇：https://blog.csdn.net/uVarAndMethod/article/details/90364461 互斥： 当多个线程访问同一个全局变量，或者同一个资源(比如打印机)的时候，需要进行线程间的互斥操作 来保证访问的安全性. 临界区、互斥体、事件和...
windows C++多线程（八）：互斥量mutex的使用
琅嬛福地
02-15 1269
互斥量可以对相关资源代码进行保护，在多线程同步中用的很多。互斥量在MFC和Qt中都有封装好的类，win32中的mutex和MFC，Qt的mutex的使用略有不同。 win32的互斥量使用方法 （1）创建互斥量CreateMutex （2）等待事件通知WaitForSingleObject （3）执行受保护的代码 （4）释放互斥量ReleaseMutex ...
Java小白一文讲清Java中集合相关的知识点（九）
Kerwin_D的博客
09-12 885
Java小白一文讲清Java中集合相关的知识点（九）
【黑马点评】已解决java.lang.NullPointerException异常
最新发布
wzc200406的博客
09-17 963
以前在遇到bug时，我总喜欢做的事是将别人写的代码复制回来。但是随着学习的深入发现，其实调代码是一件正常不过的事情，为此，锻炼自己发现问题、定位问题、解决问题能力十分重要，不断地刨根问底，才能愈发印象深刻。
Java集合（一）
小何代码咖啡馆
09-15 792
在前面已经使用了一个最基本的数据结构：数组，但是数组的缺点很明显：定长，这个缺点导致数组的增删不够方便，为了解决这个问题，可以使用Java的相关集合单列集合：集合中每一个元素只有一种元素类型多列集合：集合中每一个元素包括两种数据类型，第一个数据类型对应的元素被称为key，第二个数据类型对应的元素被称为value，二者组成的共同体被称为键值对只能存储引用数据类型的数据，而不能存储基本数据类型的数据每一种集合长度均是可变的集合中有很多使用的方法，便于调用ArrayList类是List。
C语言实现一个简单的点歌系统
嵌入式行业打工人，不定期更新博客。
09-13 1824
请注意，这只是一个非常基础的实现，实际应用中还需要考虑错误处理、输入验证、更复杂的用户界面等。此外，为了使程序更加完整，还可以添加删除歌曲、修改歌曲信息等功能。如果要保存歌曲信息，可以考虑使用文件操作来读写数据。创建一个简单的点歌系统可以用C语言实现，这里提供一个基本的框架。这个系统可以包括歌曲列表、用户选择歌曲的功能以及播放歌曲的功能。则根据用户的选择“播放”歌曲（在这里只是输出歌曲的信息）。结构体来保存每首歌的名字和艺术家名字。结构体来存储歌曲列表，并定义了。函数用于添加新歌到播放列表，
Java-数据结构-二叉树-习题(二) (´▽`)ﾉ
2303_80388948的博客
09-16 965
OK啦，今天的练习题呢就到这里就结束了，还是那句话，对于二叉树的题，我们要时刻记住递归的性质与应用。今天的题呢还是比较难理解的，我们一定要配合着画图去理解。让我们期待下一篇博吧！！！拜拜~~~
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值