windows C++ 用信号量控制线程

最新推荐文章于 2024-06-25 10:11:01 发布
最新推荐文章于 2024-06-25 10:11:01 发布
阅读量5.8k 收藏
点赞数
分类专栏： vc 文章标签： windows c++ null 多线程 thread 工作
windows C++ 用信号量控制线程
2010-08-11 09:09

很好的控制线程，让线程互斥，互相协调工作，共享数据，这个问题有很多种解决办法，不过我个人觉得使用信号量控制线程特别方便。会想到用多线程控制程序，是由于上学期我们要做一个控制电机转速的课程设计，开始编写的程序都是一个线程控制的。后来课程设计结束了，一次在看多线程的演示程序的时候突然想到，原来的那个电机控制程序完全可以写成多线程，可是由于课程设计结束了，没有硬件供你调试，就自己写了个多线程的练习程序。
控制信号量几个主要的函数：

Cpp代码
  1. WaitForSingleObject();//等待信号量有效   
  2. CreatSemaphore();//申请信号量   
  3. OpenSemaphore();//打开信号量   
  4. ReleaseSemaphore();//释放信号量  


下面来看看控制多线程要用到的东西：

Cpp代码
  1. HANDLE ptrSpdUpDown;   
  2. HANDLE ptrUpDownDraw;   
  3. HANDLE ptrDrawSpd; //申请指向信号量的句柄   
  4.    ptrSpdUpDown = ::CreateSemaphore(NULL, 0, 1, NULL);   
  5.    ptrUpDownDraw = ::CreateSemaphore(NULL, 0, 1, NULL);   
  6.    ptrDrawSpd = ::CreateSemaphore(NULL, 1, 1, NULL);//实例化三个信号量   
  7.   
  8. bOnOff=true;//线程状态控制量 开启三个线程   
  9.      m_tWriteSpeed=AfxBeginThread(WriteSpeed,   
  10.        &m_sWriteSpeed,   
  11.        THREAD_PRIORITY_NORMAL,   
  12.        0,   
  13.        CREATE_SUSPENDED);   
  14.      m_tWriteSpeed->ResumeThread();   
  15.      m_tWriteUpDown=AfxBeginThread(WriteUpDown,   
  16.        &m_sWriteUpDown,   
  17.        THREAD_PRIORITY_NORMAL,   
  18.        0,   
  19.        CREATE_SUSPENDED);   
  20.      m_tWriteUpDown->ResumeThread();   
  21.      m_tDrawWindow=AfxBeginThread(DrawWindow,   
  22.        &m_sDrawWindow,   
  23.        THREAD_PRIORITY_NORMAL,   
  24.        0,   
  25.        CREATE_SUSPENDED);   
  26.      m_tDrawWindow->ResumeThread();   
  27.   
  28. //三个线程函数   
  29. UINT WriteSpeed(LPVOID p)   
  30. {   
  31.   int iNo=1;   
  32.    CString sTr;   
  33.    CString sMe;   
  34.    CEdit *ptr=(CEdit *)p;   
  35.   while(bOnOff)   
  36.    {   
  37.      WaitForSingleObject(ptrDrawSpd,INFINITE);   
  38.      ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe+"已经接到信号");   
  39.      ::Sleep(1000);   
  40.      srand((int)time(0));//种种子数   
  41.      iSpeed=iUp+iDown+rand();   
  42.      ReleaseSemaphore(ptrSpdUpDown,1,NULL);   
  43.      sTr.Format("%d",iNo);   
  44.      sMe.Format("%d",iSpeed);   
  45.      ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe);   
  46.      iNo++;   
  47.    }   
  48.   return 0;   
  49. }   
  50. UINT WriteUpDown(LPVOID p)   
  51. {   
  52.   int iNo=1;   
  53.    CString sTr;   
  54.    CString sMe;   
  55.    CEdit *ptr=(CEdit *)p;   
  56.   while(bOnOff)   
  57.    {   
  58.      WaitForSingleObject(ptrSpdUpDown,INFINITE);   
  59.      ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe+"已经接到信号");   
  60.      ::Sleep(1000);   
  61.      srand((int)time(0));//种种子数   
  62.      iUp=iSpeed-rand();   
  63.      iDown=iSpeed+rand();   
  64.      ReleaseSemaphore(ptrUpDownDraw,1,NULL);   
  65.      sTr.Format("%d",iNo);   
  66.      sMe.Format("%d",iUp);   
  67.      ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe);   
  68.      iNo++;   
  69.    }   
  70.   return 0;   
  71. }   
  72. UINT DrawWindow(LPVOID p)   
  73. {   
  74.   int iNo=1;   
  75.    CString sTr;   
  76.    CEdit *ptr=(CEdit *)p;   
  77.   while(bOnOff)   
  78.    {   
  79.      WaitForSingleObject(ptrUpDownDraw,INFINITE);   
  80.      ptr->SetWindowText("线程DrawWindow正在运行"+sTr+"已经接到信号");   
  81.      ::Sleep(1000);   
  82.      sTr.Format("%d",iNo);   
  83.      ptr->SetWindowText("线程DrawWindow正在运行"+sTr);   
  84.      iNo++;   
  85.      ReleaseSemaphore(ptrDrawSpd,1,NULL);   
  86.    }   
  87.   return 0;   
  88. }  

上面的方法是先申请信号量的句柄然后再实例化信号量 下面这种方法是直接申请信号量 两种方法基本相同

Cpp代码
  1. CSemaphore ptrSpdUpDown(0, 1);   
  2. CSemaphore ptrUpDownDraw(0, 1);   
  3. CSemaphore ptrDrawSpd(1, 1);//#include <atlsync.h>注意在stdafx.h手动包含这个文件  

在各个线程函数中不用WaitForSingleObject了要使用Lock()UnLock();
下面是使用CSemaphore后在各个线程函数中使用Lock()UnLock()替换掉WaitForSingleObject的结果

Cpp代码
  1. UINT WriteSpeed(LPVOID p)   
  2. {   
  3.   int iNo=1;   
  4.    CString sTr;   
  5.    CString sMe;   
  6.    CEdit *ptr=(CEdit *)p;   
  7.   while(bOnOff)   
  8.    {   
  9.      <STRONG>ptrDrawSpd.Lock();</STRONG>   
  10.      ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe+"已经接到信号");   
  11.      ::Sleep(1000);   
  12.      srand((int)time(0));//种种子数   
  13.      iSpeed=iUp+iDown+rand();   
  14.      ReleaseSemaphore(ptrSpdUpDown,1,NULL);   
  15.      <STRONG>ptrSpdUpDown.Unlock();</STRONG>   
  16.      sTr.Format("%d",iNo);   
  17.      sMe.Format("%d",iSpeed);   
  18.      ptr->SetWindowText("线程WriteSpeed正在运行"+sTr+"---Speed:"+sMe);   
  19.      iNo++;   
  20.    }   
  21.   return 0;   
  22. }   
  23. UINT WriteUpDown(LPVOID p)   
  24. {   
  25.   int iNo=1;   
  26.    CString sTr;   
  27.    CString sMe;   
  28.    CEdit *ptr=(CEdit *)p;   
  29.   while(bOnOff)   
  30.    {   
  31.      <STRONG>ptrSpdUpDown.Lock();</STRONG>   
  32.      ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe+"已经接到信号");   
  33.      ::Sleep(1000);   
  34.      srand((int)time(0));//种种子数   
  35.      iUp=iSpeed-rand();   
  36.      iDown=iSpeed+rand();   
  37.      ReleaseSemaphore(ptrUpDownDraw,1,NULL);   
  38.      <STRONG>ptrUpDownDraw.Unlock();</STRONG>   
  39.      sTr.Format("%d",iNo);   
  40.      sMe.Format("%d",iUp);   
  41.      ptr->SetWindowText("线程WriteUpDown正在运行"+sTr+"---Up:"+sMe);   
  42.      iNo++;   
  43.    }   
  44.   return 0;   
  45. }   
  46. UINT DrawWindow(LPVOID p)   
  47. {   
  48.   int iNo=1;   
  49.    CString sTr;   
  50.    CEdit *ptr=(CEdit *)p;   
  51.   while(bOnOff)   
  52.    {   
  53.      <STRONG>ptrUpDownDraw.Lock();</STRONG>   
  54.      ptr->SetWindowText("线程DrawWindow正在运行"+sTr+"已经接到信号");   
  55.      ::Sleep(1000);   
  56.      sTr.Format("%d",iNo);   
  57.      ptr->SetWindowText("线程DrawWindow正在运行"+sTr);   
  58.      iNo++;   
  59.      ReleaseSemaphore(ptrDrawSpd,1,NULL);   
  60.      <STRONG>ptrDrawSpd.Unlock();</STRONG>   
  61. }   
  62.   return 0;   
  63. }  

推荐使用第一种方法，第一种方法只声明了句柄，当信号量实例化的时候句柄才指向三个信号量。所以更加支持多态。

susubuhui
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
windowsC++多线程加锁信号量共享内存
07-07
windowsC++多线程加锁信号量共享内存
VC 信号量
weixin_42193704的博客
10-21 1049
使用函数CreateEvent创建一个事件 HANDLE CreateEvent( 　　LPSECURITY_ATTRIBUTES lpEventAttributes, // SD 一般为空 　　BOOL bManualReset, // reset t...
【C++并发编程】（八）信号量
最新发布
weixin_44378835的博客
06-25 1066
信号量的计数值是一个非负整数，表示可用资源的数量。如果信号量的计数值为0，则线程或进程将被阻塞，直到信号量的计数值大于0。为了有效管理这些预订，店主可以采用类似于计数信号量的系统来确保桌子的合理分配和预订管理。二值信号量只有两个状态（0 和 1），类似于互斥锁，主要用于控制单个资源的访问。信号量可以用于线程间的同步，使得某些操作按特定顺序执行，从而避免竞态条件的发生，也可以限制对共享资源的并发访问数量，以防止资源过载。创建，并指定其最大计数值（桌子数量）和初始计数值（空闲的桌子数量）。
[modern c++] c++ 11 实现 Windows 下的信号量
ykun089的博客
10-14 476
Windows 下 有CreateSemaphore 来创建信号量，c++ 11 没有实现信号量，可以用条件变量来模拟信号量： class CSemaphore { public: CSemaphore(); ~CSemaphore(); void semaphoreP(unsigned int timeout = 0) { std::unique_lock<std::mutex&.
多线程之信号量（By C++）
ucliaohh的专栏
12-14 170
多线程之信号量（By C++）
c++多线程同步——信号量
04-27
MFC（Microsoft Foundation Classes）虽然主要用于Windows开发，但它并不直接支持C++11多线程特性，因此可能需要额外的手段来实现信号量。 在MFC工程中，我们可以通过创建一个自定义的信号量类，基于Windows API的`...
Visual C++信号量线程同步的简单实例工程
12-01
本实例工程“Visual C++信号量线程同步的简单实例工程”聚焦于如何通过信号量（Semaphore）实现线程间的协调与同步，以确保资源的有效管理和避免竞态条件。 首先，我们需要理解什么是信号量。信号量是一种同步原语...
使用信号量进行线程同步VC源代码
03-15
本资源提供的"使用信号量进行线程同步VC源代码"是一个实例，展示了如何在Microsoft Visual C++（VC）环境中利用MFC（Microsoft Foundation Classes）库中的`CSemaphore`类来实现这一目标。`CSemaphore`是MFC对操作...
Windows 多线程API C++类的封装
07-04
6. **syncronization objects**：例如事件、信号量、互斥量等，作为成员变量，提供线程同步的接口。 在类的设计中，可以考虑使用模板，使得线程函数能够处理不同类型的参数。还可以添加异常安全性和资源管理，例如...
C/C++中退出线程的四种解决方法
09-05
如果线程需要在非主函数的位置退出，可以考虑使用信号量、事件或条件变量等同步机制来通知线程主函数，由主函数决定是否退出，这样可以避免潜在的问题，如资源泄漏和数据一致性问题。 微软也强调，虽然提供 `...
VC线程信号量的使用举例
11-05
　VC线程信号量的使用举例源码，点击启动线程，可发现出现了什么。介绍线程方面的基础知识技巧。
c++多线程编程的十个例子
08-21
为了防止这种问题，我们可以使用同步机制，如互斥量(`std::mutex`)、条件变量(`std::condition_variable`)和信号量(`std::semaphore`)。一个例子可能是两个线程共享一个资源，一个线程读取，另一个线程写入，互斥量...
信号量实现多线程同步
05-11
利用多线程原理模拟生产与消费的互斥同步过程，使用了信号量
使用信号量实现线程同步
10-14
在Windows系统中，信号量作为内核对象被广泛使用，可以用来控制对共享资源的访问。 信号量的核心概念是“计数”，它可以是正整数或零。当计数为非零时，表示资源可用；计数为零，则表示资源暂时不可用。线程通过...
Windows Using Semaphore Objects
lixiaoguang20的博客
12-26 156
The following example uses asemaphore objectto limit the number of threads that can perform a particular task. First, it uses theCreateSemaphorefunction to create the semaphore and to specify init...
操作系统-信号量C++代码WIN32
独行者103的专栏
07-12 994
#include #include #include #include #include #define BUFFER_SIZE 5 int buffer[BUFFER_SIZE]; int cnt=0; HANDLE Mutex,Empty,Full; void init() { Mutex=CreateMutex(NULL,FALSE,NULL); Empty=Create
c++ 如何使用信号量挂起线程
05-30
在 C++ 中，可以使用 `std::mutex` 和 `std::condition_variable` 实现信号量来挂起线程。下面是一个简单的示例： ```c++ #include <mutex> #include <condition_variable> class Semaphore { public: Semaphore(int count = 0) : count_(count) {} void notify() { std::unique_lock<std::mutex> lock(mutex_); ++count_; cv_.notify_one(); } void wait() { std::unique_lock<std::mutex> lock(mutex_); while (count_ == 0) { cv_.wait(lock); } --count_; } private: std::mutex mutex_; std::condition_variable cv_; int count_; }; ``` 在上面的示例中，`Semaphore` 类中包含了一个计数器 `count_`，并且提供了 `notify()` 和 `wait()` 两个方法，分别用于增加计数器和减少计数器并等待计数器不为零。当计数器为零时，线程会被挂起等待 `notify()` 方法的通知。 使用示例： ```c++ #include <iostream> #include <thread> Semaphore sem(0); void worker() { std::cout << "worker start" << std::endl; sem.wait(); std::cout << "worker end" << std::endl; } int main() { std::thread t(worker); std::this_thread::sleep_for(std::chrono::seconds(1)); std::cout << "main notify" << std::endl; sem.notify(); t.join(); return 0; } ``` 在上面的示例中，主线程会等待 1 秒后调用 `notify()` 方法通知子线程继续执行。子线程在 `wait()` 方法处被挂起，直到收到通知后才继续执行。输出结果为： ``` worker start main notify worker end ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值