VC下线程同步的三种方法(互斥、事件、临界区)

最新推荐文章于 2020-02-23 17:59:26 发布
最新推荐文章于 2020-02-23 17:59:26 发布
阅读量377 收藏
点赞数 1
分类专栏： MFC 文章标签： MFC

VC下线程同步的三种方法(互斥、事件、临界区)   

2008-01-25 09:57:59|  分类： VC |  标签： |举报 |字号大中小 订阅


首选使用临界区对象,主要原因是使用简单。
EnterCriticalSection（）函数等候指定的危险区段对象的所有权。当调用的线程被允许所有权时，函数返回。
EnterCriticalSection（），一个单独进程的线程可以使用一个危险区段对象作为相互-排除同步。 进程负责分配被一个危险区段对象使用的内存, 它藉由声明一个CRITICAL_SECTION类型 的变量实现。在使用一个危险区段之前，进程的一些线程必须调用 InitializeCriticalSection 函数设定对象的初值.
为了要使互斥的访问被共享的资源,每个线程调用EnterCriticalSection 或者 TryEnterCriticalSection 功能，在执行访问被保护资源的任何代码段之前，请求危险区段的所有权。

#include <windows.h>

#include <iostream>

using namespace std;

DWORD WINAPI Fun1Proc(LPVOID lpParameter);

DWORD WINAPI Fun2Proc(LPVOID lpParameter);

int tickets=100;

CRITICAL_SECTION g_csA;

CRITICAL_SECTION g_csB;

void main()

{

 HANDLE hThread1;

 HANDLE hThread2;

 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

 CloseHandle(hThread1);

 CloseHandle(hThread2);

 InitializeCriticalSection(&g_csA);

 InitializeCriticalSection(&g_csB);

 Sleep(40000);

 DeleteCriticalSection(&g_csA);

 DeleteCriticalSection(&g_csB);

}

DWORD WINAPI Fun1Proc(LPVOID lpParameter)

{

 while (TRUE)

 {

  EnterCriticalSection(&g_csA);

  Sleep(1);

  //EnterCriticalSection(&g_csB);//临界区的同步和互锁

  if (tickets>0)

  {

   Sleep(1);

   cout<<"Thread1 sell ticket :"<<tickets--<<endl;

   //LeaveCriticalSection(&g_csB);

   LeaveCriticalSection(&g_csA);

  }

  else

  {

   //LeaveCriticalSection(&g_csB);

   LeaveCriticalSection(&g_csA);

   break;

  }

 }

 return 0;

}

DWORD WINAPI Fun2Proc(LPVOID lpParameter)

{

 while (TRUE)

 {

  EnterCriticalSection(&g_csB);

  Sleep(1);

  EnterCriticalSection(&g_csA);

  if (tickets>0)

  {

   Sleep(1);

   cout<<"Thread2 sell ticket :"<<tickets--<<endl;

   LeaveCriticalSection(&g_csA);

   LeaveCriticalSection(&g_csB);

  }

  else

  {

   LeaveCriticalSection(&g_csA);

   LeaveCriticalSection(&g_csB);

   break;

  }

 }

 return 0;

}


--------------------------------------------------------------------------------

 

二、使用互斥对象
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
如果时间是有信号状态返回WAIT_OBJECT_0，如果时间超过dwMilliseconds值但时间事件还是无信号状态则返回WAIT_TIMEOUT
WaitForSingleObject函数用来检测hHandle事件的信号状态，当函数的执行时间超过dwMilliseconds就返回，但如果参数dwMilliseconds为INFINITE时函数将直到相应时间事件变成有信号状态才返回，否则就一直等待下去，直到WaitForSingleObject有返回直才执行后面的代码。

#include <windows.h>

#include <iostream>

using namespace std;

DWORD WINAPI Fun1Proc(LPVOID lpParameter);

DWORD WINAPI Fun2Proc(LPVOID lpParameter);

int index =0;

int tickets=100;

HANDLE hMutex;

void main()

{

 HANDLE hThread1;

 HANDLE hThread2;

 //创建线程

 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);

 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

 CloseHandle(hThread1);

 CloseHandle(hThread2);

 //**************************************************************

 //保证应用程序只有一个实例运行,创建一个命名的互斥对象.

 hMutex=CreateMutex(NULL,TRUE,LPCTSTR("tickets"));

 //创建时主线程拥有该互斥对象,互斥对象的线程ID为主线程的ID,同时将该互斥对象内部计数器置为1

 if (hMutex)

 {

  if (ERROR_ALREADY_EXISTS==GetLastError())

  {

   cout<<"only one instance can run!"<<endl;

   //Sleep(40000);

   return;

  }

 }

 //**************************************************************

 WaitForSingleObject(hMutex,INFINITE);

 //使用该函数请求互斥对象时,虽说该对象处于无信号状态,但因为请求的线程ID和该互斥对象所有者的线程ID是相同的.所以仍然可以请求到这个互斥对象,于是该互斥对象内部计数器加1,内部计数器的值为2. 意思是有两个等待动作

 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象内部计数器的值递减1,操作系统不会将这个互斥对象变为已通知状态.

 ReleaseMutex(hMutex);//释放一次互斥对象,该互斥对象内部计数器的值为0,同时将该对象设置为已通知状态.

 //对于互斥对象来说,谁拥有谁释放

 Sleep(40000);

}

DWORD WINAPI Fun1Proc(LPVOID lpParameter)

{

 while (TRUE)

 {

  WaitForSingleObject(hMutex,INFINITE);//等待互斥对象有信号

  if (tickets>0)

  {

   Sleep(1);

   cout<<"thread1 sell ticket :"<<tickets--<<endl;

  }

  else

   break;

  ReleaseMutex(hMutex);//设置该互斥对象的线程ID为0,并且将该对象设置为有信号状态

 }

 return 0;

}

DWORD WINAPI Fun2Proc(LPVOID lpParameter)

{

 while (TRUE)

 {

  WaitForSingleObject(hMutex,INFINITE);

  if (tickets>0)

  {

   Sleep(1);

   cout<<"thread2 sell ticket :"<<tickets--<<endl;

  }

  else

   break;

  ReleaseMutex(hMutex);

 }

 return 0;

}


--------------------------------------------------------------------------------


三、使用事件对象
HANDLE     CreateEvent(   
        LPSECURITY_ATTRIBUTES     lpEventAttributes,           //     SD   
        BOOL     bManualReset,                                                 //     reset     type   
        BOOL     bInitialState,                                                     //     initial     state   
        LPCTSTR     lpName                                                      //     object     name   
    );   
    该函数创建一个Event同步对象,并返回该对象的Handle   
   
    lpEventAttributes     一般为NULL   
    bManualReset               创建的Event是自动复位还是人工复位     ,如果true,人工复位,   
    一旦该Event被设置为有信号,则它一直会等到ResetEvent()API被调用时才会恢复   
    为无信号.     如果为false,Event被设置为有信号,则当有一个wait到它的Thread时,   
    该Event就会自动复位,变成无信号.   
    bInitialState             初始状态,true,有信号,false无信号   
    lpName                           Event对象名   
   
    一个Event被创建以后,可以用OpenEvent()API来获得它的Handle,用CloseHandle()   
    来关闭它,用SetEvent()或PulseEvent()来设置它使其有信号,用ResetEvent()   
    来使其无信号,用WaitForSingleObject()或WaitForMultipleObjects()来等待   
    其变为有信号.   
   
    PulseEvent()是一个比较有意思的使用方法,正如这个API的名字,它使一个Event   
    对象的状态发生一次脉冲变化,从无信号变成有信号再变成无信号,而整个操作是原子的.   
    对自动复位的Event对象,它仅释放第一个等到该事件的thread（如果有),而对于   
    人工复位的Event对象,它释放所有等待的thread.  

#include <windows.h>
#include <iostream>
using namespace std;
DWORD WINAPI Fun1Proc(LPVOID lpParameter);
DWORD WINAPI Fun2Proc(LPVOID lpParameter);
int tickets=100;
HANDLE g_hEvent;

void main()
{
 HANDLE hThread1;
 HANDLE hThread2;
 //**************************************************
 //创建一个命名的自动重置事件内核对象
 g_hEvent=CreateEvent(NULL,FALSE,FALSE,LPCTSTR("tickets"));
 if (g_hEvent)
 {
  if (ERROR_ALREADY_EXISTS==GetLastError())
  {
   cout<<"only one instance can run!"<<endl;
   return;
  }
 }
 //**************************************************
 SetEvent(g_hEvent);
 //创建线程
 hThread1=CreateThread(NULL,0,Fun1Proc,NULL,0,NULL);
 hThread2=CreateThread(NULL,0,Fun2Proc,NULL,0,NULL);

 Sleep(40000);
 //关闭事件对象句柄
 CloseHandle(g_hEvent);
}

DWORD WINAPI Fun1Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  WaitForSingleObject(g_hEvent,INFINITE);
  //ResetEvent(g_hEvent);
  if (tickets>0)
  {
   Sleep(1);
   cout<<"thread1 sell ticket :"<<tickets--<<endl;
   SetEvent(g_hEvent);
  }
  else
  {
   SetEvent(g_hEvent);
   break;
  }
 }
 return 0;
}

DWORD WINAPI Fun2Proc(LPVOID lpParameter)
{
 while (TRUE)
 {
  WaitForSingleObject(g_hEvent,INFINITE);
  //ResetEvent(g_hEvent);
  if (tickets>0)
  {
   cout<<"Thread2 sell ticket :"<<tickets--<<endl;
   SetEvent(g_hEvent);
  }
  else
  {
   SetEvent(g_hEvent);
   break;
  }
 }
 return 0;
}


原文：http://blog.163.com/junior_zhong/blog/static/27871180200802595759702/

Grim_Rapier
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VC++线程同步的四种方式(事件(Event)、信号量(semaphore)、互斥量(mutex)、临界区(Critical section))
大兵小杰
05-29 1666
一、概述:为什么要做线程同步？ 在程序中使用多线程时，一般很少有多个线程能在其生命期内进行完全独立的操作。更多的情况是一些线程进行某些处理操作，而其他的线程必须对其处理结果进行访问。正常情况下对这种处理结果的访问应当在其处理任务完成后进行。 如果不采取适当的措施，其他线程往往会在线程处理任务结束前就去访问处理结果，这就很有可能得到有关处理结果的错误访问,例如，多个线程同时访问同...
C++多线程编程3（线程互斥）
最新发布
jqgogogo的博客
08-27 119
c++线程互斥
VC++中多线程学习(MFC多线程)三（线程同步包含：原子互锁、关键代码段、互斥器Mutex、Semaphores（信号量）、Event Objects（事件））
进击的菜鸟
02-23 1110
线程同步的必要性： 我们知道操作系统的执行最小单位是线程，而一个进程包含了很多的线程，现在已经实现了 真正的并行，如双核cpu，在每个核心里开一个进程，则双核cpu就可以开两个并行运行的进程 而在每个进程类又可以开很多的线程，这里需要强调的是在两个核跑的两个进程是实实在在的并行的， 不会互相干扰，但是在每个核的进程中又运行了很多的线程，而这些线程并不是并行的，而是串行的，即操作系统会在线程中...
vc++中的线程锁（线程锁保持线程同步）
11-05
简单学习用例，利用线程锁对线程同步进行控制，保证对公共资源的访问不出现错误！
VC下线程同步的三种方法
05-30
VC下线程同步的三种方法(互斥、事件、临界区）简单的代码，让你更容易理解三种同步方式。
四种进程或线程同步互斥的控制方法介绍
02-21
很想整理一下自己对进程线程同步互斥的理解。正巧周六一个刚刚回到学校的同学请客吃饭。...这4种方法具体定义如下在《操作系统教程》ISBN7-5053-6193-7一书中可以找到更加详细的解释1、临界区:通过对多线程的
使用临界区来实现多线程的同步互斥.critical section
03-28
使用临界区来实现多线程的同步互斥.critical section
线程同步的四种详细使用方法--临界区、互斥量、事件等
04-26
线程同步的四种详细使用方法--临界区、互斥量、事件等
VC多线程临界区
aoe41606的博客
02-05 151
在使用多线程时，一般非常少有多个线程全然独立的工作。往往是多个线程同一时候操作一个全局变量来获取程序的执行结果。多个线程同一时候訪问同一个全局变量，假设都是读取操作，则不会出现故障。假设是写操作，则会错误发生。这时候，我们能够通过临界区，为全局变量设置一个保护，保证同一时候仅仅有一个线程能够訪问此变量。其它变量进入等待状态。 ...
vc互斥多线程
07-12
两个线程同步,实现两个窗口售票,不允有窗口连续卖出两票
使用三种VC的多线程同步方法编写一个多线程的程序
04-03
1.使用三种VC的多线程同步方法编写一个多线程的程序（要求在屏幕上先显示Hello，再显示World）。 1）基于全局变量的多线程同步程序； 2）基于事件的多线程同步程序； 3）基于临界区的多线程同步程序。
VC++中四种进程或线程同步互斥的控制方法
woshizhanhun的专栏
09-17 2322
          现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。 这4种方法具体定义如下 在《操作系统教程》ISBN 7-5053-6193-7 一书中可以找到更加详细的解释     1临界区:通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问。  
VC++ 任务队列（线程同步锁）
老狼的专栏
12-25 379
线程同步锁（Synchronized.h）： #pragma once #include <windows.h> #include <process.h> class Synchronized { protected: HANDLE _hMutex; bool _acquired; public: Synchronized(): _hMutex(NULL)...
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
热门推荐
青萍之末的博客
10-06 7万+
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以...
VC 线程加锁，互斥信号量Mutex
奔流的江水
10-17 3102
https://blog.csdn.net/chexlong/article/details/7051193
<MFC笔记> 四种线程同步（或互斥）方式小结
EbowTang的练习场
06-10 9234
一，什么是线程同步？ 同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。这里的同步千万不要理解成那个同时进行，应是指协同、协助、互相配合。 线程同步是指多线程通过特定的设置（如互斥量，事件对象，临界区）来控制线程之间的执行顺序（即所谓的同步）也可以说是在线程之间通过同步建立起执行顺序的关系，如果没有同步，那线程之间是各自运行各自的！ 二，线程同步的方式和机制： 临
在C++中实现同步锁
weixin_34248849的博客
03-13 237
在做C++的项目中发现，由于用惯了c#的lock（）{}和java的Synchronize（）｛｝，windows自带的临界区，互斥量，内核事件，信号量用起来不太习惯，于是打算自己在vc++中封装一个类似的东东。封装这个我决定采用一个临界区来做，最终的形式如下： 　　synchronize(object) 　　{ 　　//....无论此处是否发生异常，object都能被...
请用三种vc的多线程同步方法编写一个多线程的 程 序
05-02
在VC中，可以使用三种多线程同步方法，分别是临界区（CriticalSection）、事件（Event）、互斥体（Mutex）。下面是一个使用这三种方法的多线程程序的示例： #include <windows.h> #include <iostream> using namespace std; int g_iCount = 0; CRITICAL_SECTION g_cs; //定义临界区 HANDLE g_hEvent; //定义事件句柄 HANDLE g_hMutex; //定义互斥体句柄 DWORD WINAPI ThreadFunc(LPVOID lpParam) { for (int i = 0; i < 100000; i++) { EnterCriticalSection(&g_cs); //进入临界区 g_iCount++; //临界区内进行操作 LeaveCriticalSection(&g_cs); //退出临界区 SetEvent(g_hEvent); //设置事件 WaitForSingleObject(g_hMutex, INFINITE); //等待互斥体 g_iCount--; //互斥体中进行操作 ReleaseMutex(g_hMutex); //释放互斥体 } return 0; } int main(int argc, char* argv[]) { HANDLE hThread[2]; DWORD dwThreadId[2]; InitializeCriticalSection(&g_cs); //初始化临界区 g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //创建事件 g_hMutex = CreateMutex(NULL, FALSE, NULL); //创建互斥体 for (int i = 0; i < 2; i++) { hThread[i] = CreateThread(NULL, 0, ThreadFunc, NULL, 0, &dwThreadId[i]); //创建线程 } for (int i = 0; i < 2; i++) { WaitForSingleObject(hThread[i], INFINITE); //等待线程结束 } cout << "iCount = " << g_iCount << endl; DeleteCriticalSection(&g_cs); //删除临界区 CloseHandle(g_hEvent); //关闭事件句柄 CloseHandle(g_hMutex); //关闭互斥体句柄 return 0; } 上面的程序中，首先定义了一个全局变量g_iCount，用于计数。然后定义了一个临界区g_cs、一个事件句柄g_hEvent、一个互斥体句柄g_hMutex。在主函数中，首先初始化临界区、创建事件句柄、创建互斥体句柄。然后创建两个线程，每个线程都调用ThreadFunc函数。在ThreadFunc函数中，通过EnterCriticalSection和LeaveCriticalSection进入和退出临界区。通过SetEvent设置事件，并通过WaitForSingleObject等待互斥体。通过ReleaseMutex释放互斥体。最后主函数等待两个线程结束，并输出计数结果。最后删除临界区，关闭事件句柄和互斥体句柄。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值