互斥量临界区信号量和时间的作用与区别精.docx
《互斥量临界区信号量和时间的作用与区别精.docx》由会员分享，可在线阅读，更多相关《互斥量临界区信号量和时间的作用与区别精.docx（16页珍藏版）》请在冰点文库上搜索。
互斥量临界区信号量和时间的作用与区别精
互斥量、临界区、信号量和时间的作用与区别
不管是辅助线程还是用户接口线程,在存取共享资源时,都需要保护共享资源,以免引起冲突,造成错误。
处理方法类似于Win32API函数的使用,但MFC为我们提供了几个同步对象C++类,即CSyncObject、CMutex、CSemaphore、CEvent、CCriticalSection。
这里,CSyncObject为其它四个类的基类,后四个类分别对应前面所讲的四个Win32API同步对象。
通常,我们在C++对象的成员函数中使用共享资源,或者把共享资源封装在C++类的内部。
我们可将线程同步操作封装在对象类的实现函数当中,这样在应用中的线程使用C++对象时,就可以像一般对象一样使用它,简化了使用部分代码的编写,这正是面向对象编程的思想。
这样编写的类被称作"线程安全类"。
在设计线程安全类时,首先应根据具体情况在类中加入一个同步对象类数据成员。
然后,在类的成员函数中,凡是所有修改公共数据或者读取公共数据的地方均要加入相应的同步调用。
一般的处理步骤是:
创建一个CSingleLock或者CMultiLock对象,然后调用其Lock函数。
当对象结束时,自动在析构函数中调用Unlock函数,当然也可以在任何希望的地方调用Unlock函数。
如果不是在特定的C++对象中使用共享资源,而是在特定的函数中使用共享资源（这样的函数称为"线程安全函数",那么还是按照前面介绍的办法去做:
先建立同步对象,然后调用等待函数,直到可以访问资源,最后释放对同步对象的控制。
下面我们讨论四个同步对象分别适用的场合:
（1如果某个线程必须等待某些事件发生后才能存取相应资源,则用CEvent;
（2如果一个应用同时可以有多个线程存取相应资源,则用CSemaphore;
（3如果有多个应用（多个进程同时存取相应资源,则用CMutex,否则用CCriticalSection。
使用线程安全类或者线程安全函数进行编程,比不考虑线程安全的编程要复杂,尤其在进行调试时情况更为复杂,我们必须灵活使用VisualC++提供的调试工具,以保证共享资源的安全存取。
线程安全编程的另一缺点是运行效率相对要低些,即使在单个线程运行的情况下也会损失一些效率。
所以,我们在实际工作中应具体问题具体分析,以选择合适的编程方法。
OS中的解说及详细编程使用:
1.临界区:
通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问。
2.互斥量:
为协调共同对一个共享资源的单独访问而设计的。
3.信号量:
为控制一个具有有限数量用户资源而设计。
4.事件:
用来通知线程有一些事件已发生,从而启动后继任务的开始。
临界区（CriticalSection
保证在某一时刻只有一个线程能访问数据的简便办法。
在任意时刻只允许一个线程对共享资源进行访问。
如果有多个线程试图同时访问临界区,那么在有一个线程进入后其他所有试图访问此临界区的线程将被挂起,并一直持续到进入临
界区的线程离开。
临界区在被释放后,其他线程可以继续抢占,并以此达到用原子方式操作共享资源的目的。
临界区包含两个操作原语:
EnterCriticalSection（进入临界区LeaveCriticalSection（离开临界区
EnterCriticalSection（语句执行后代码将进入临界区以后无论发生什么,必须确保与之匹配的LeaveCriticalSection（都能够被执行到。
否则临界区保护的共享资源将永远不会被释放。
虽然临界区同步速度很快,但却只能用来同步本进程内的线程,而不可用来同步多个进程中的线程。
MFC提供了很多功能完备的类,我用MFC实现了临界区。
MFC为临界区提供有一个CCriticalSection类,使用该类进行线程同步处理是非常简单的。
只需在线程函数中用CCriticalSection类成员函数Lock（和UnLock（标定出被保护代码片段即可。
Lock（后代码用到的资源自动被视为临界区内的资源被保护。
UnLock后别的线程才能访问这些资源。
//CriticalSection
CCriticalSectionglobal_CriticalSection;
//共享资源
charglobal_Array[256];
//初始化共享资源
voidInitializeArray（
{
for（inti=0;i<256;i++
{
global_Array[i]=I;
}
}
//写线程
UINTGlobal_ThreadWrite（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
//进入临界区
global_CriticalSection.Lock（;
for（inti=0;i<256;i++
{
global_Array[i]=W;
ptr->SetWindowText（global_Array;
Sleep（10;
}
//离开临界区
global_CriticalSection.Unlock（;
return0;
}
//删除线程
UINTGlobal_ThreadDelete（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
//进入临界区
global_CriticalSection.Lock（;
for（inti=0;i<256;i++
{
global_Array[i]=D;
ptr->SetWindowText（global_Array;
Sleep（10;
}
//离开临界区
global_CriticalSection.Unlock（;
return0;
}
//创建线程并启动线程
voidCCriticalSectionsDlg:
:
OnBnClickedButtonLock（
{
//StartthefirstThread
CWinThread*ptrWrite=AfxBeginThread（Global_ThreadWrite,
&m_Write,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED;
ptrWrite->ResumeThread（;
//StartthesecondThread
CWinThread*ptrDelete=AfxBeginThread（Global_ThreadDelete,&m_Delete,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED;
ptrDelete->ResumeThread（;
}
在测试程序中,LockUnLock两个按钮分别实现,在有临界区保护共享资源的执行状态,和没有临界区保护共享资源的执行状态。
程序运行结果
互斥量（Mutex
互斥量跟临界区很相似,只有拥有互斥对象的线程才具有访问资源的权限,由于互斥对象只有一个,因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。
当前占据资源的线程在任务处理完后应将拥有的互斥对象交出,以便其他线程在获得后得以访问资源。
互斥量比临界区复杂。
因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享,而且可以在不同应用程序的线程之间实现对资源的安全共享。
互斥量包含的几个操作原语:
CreateMutex（创建一个互斥量
OpenMutex（打开一个互斥量
ReleaseMutex（释放互斥量
WaitForMultipleObjects（等待互斥量对象
同样MFC为互斥量提供有一个CMutex类。
使用CMutex类实现互斥量操作非常简单,但是要特别注意对CMutex的构造函数的调用
CMutex（BOOLbInitiallyOwn=FALSE,LPCTSTRlpszName=NULL,LPSECURITY_ATTRIBUTESlpsaAttribute=NULL
不用的参数不能乱填,乱填会出现一些意想不到的运行结果。
//创建互斥量
CMutexglobal_Mutex（0,0,0;
//共享资源
charglobal_Array[256];
voidInitializeArray（
{
for（inti=0;i<256;i++
{
global_Array[i]=I;
}
}
UINTGlobal_ThreadWrite（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
global_Mutex.Lock（;
for（inti=0;i<256;i++
{
global_Array[i]=W;
ptr->SetWindowText（global_Array;
Sleep（10;
}
global_Mutex.Unlock（;
return0;
}
UINTGlobal_ThreadDelete（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
global_Mutex.Lock（;
for（inti=0;i<256;i++
{
global_Array[i]=D;
ptr->SetWindowText（global_Array;
Sleep（10;
}
global_Mutex.Unlock（;
return0;
}
同样在测试程序中,LockUnLock两个按钮分别实现,在有互斥量保护共享资源的执行状态,和没有互斥量保护共享资源的执行状态。
程序运行结果
信号量（Semaphores
信号量对象对线程的同步方式与前面几种方法不同,信号允许多个线程同时使用共享资源,这与操作系统中的PV操作相同。
它指出了同时访问共享资源的线程最大数目。
它允许多个线程在同一时刻访问同一资源,但是需要限制在同一时刻访问此资源的最大线程数目。
在用CreateSemaphore（创建信号量时即要同时指出允许的最大资源计数和当前可用资源计数。
一般是将当前可用资源计数设置为最大资源计数,每增加一个线程对共享资源的访问,当前可用资源计数就会减1,只要当前可用资源计数是大于0的,就可以发出信号量信号。
但是当前可用计数减小到0时则说明当前占用资源的线程数已经达到了所允许的最大数目,不能在允许其他线程的进入,此时的信号量信号将无法发出。
线程在处理完共享资源后,应在离开的同时通过ReleaseSemaphore（函数将当前可用资源计数加1。
在任何时候当前可用资源计数决不可能大于最大资源计数。
PV操作及信号量的概念都是由荷兰科学家E.W.Dijkstra提出的。
信号量S是一个整数,S大于等于零时代表可供并发进程使用的资源实体数,但S小于零时则表示正在等待使用共享资源的进程数。
P操作申请资源:
（1S减1;
（2若S减1后仍大于等于零,则进程继续执行;
（3若S减1后小于零,则该进程被阻塞后进入与该信号相对应的队列中,然后转入进程调度。
V操作释放资源:
（1S加1;
（2若相加结果大于零,则进程继续执行;
（3若相加结果小于等于零,则从该信号的等待队列中唤醒一个等待进程,然后再返回原进程继续执行或转入进程调度。
信号量包含的几个操作原语:
CreateSemaphore（创建一个信号量
OpenSemaphore（打开一个信号量
ReleaseSemaphore（释放信号量
WaitForSingleObject（等待信号量
//信号量句柄
HANDLEglobal_Semephore;
//共享资源
charglobal_Array[256];
voidInitializeArray（
{
for（inti=0;i<256;i++
{
global_Array[i]=I;
}
}
//线程1
UINTGlobal_ThreadOne（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
//等待对共享资源请求被通过等于P操作WaitForSingleObject（global_Semephore,INFINITE;for（inti=0;i<256;i++
{
global_Array[i]=O;
ptr->SetWindowText（global_Array;
Sleep（10;
}
//释放共享资源等于V操作
ReleaseSemaphore（global_Semephore,1,NULL;return0;
}
UINTGlobal_ThreadTwo（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
WaitForSingleObject（global_Semephore,INFINITE;for（inti=0;i<256;i++
{
global_Array[i]=T;
ptr->SetWindowText（global_Array;
Sleep（10;
}
ReleaseSemaphore（global_Semephore,1,NULL;return0;
}
UINTGlobal_ThreadThree（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
WaitForSingleObject（global_Semephore,INFINITE;
for（inti=0;i<256;i++
{
global_Array[i]=H;
ptr->SetWindowText（global_Array;
Sleep（10;
}
ReleaseSemaphore（global_Semephore,1,NULL;
return0;
}
voidCSemaphoreDlg:
:
OnBnClickedButtonOne（
{
//设置信号量1个资源1同时只可以有一个线程访问
global_Semephore=CreateSemaphore（NULL,1,1,NULL;
this->StartThread（;
//TODO:
Addyourcontrolnotificationhandlercodehere
}
voidCSemaphoreDlg:
:
OnBnClickedButtonTwo（
{
//设置信号量2个资源2同时只可以有两个线程访问
global_Semephore=CreateSemaphore（NULL,2,2,NULL;
this->StartThread（;
//TODO:
Addyourcontrolnotificationhandlercodehere
}
voidCSemaphoreDlg:
:
OnBnClickedButtonThree（
{
//设置信号量3个资源3同时只可以有三个线程访问
global_Semephore=CreateSemaphore（NULL,3,3,NULL;
this->StartThread（;
//TODO:
Addyourcontrolnotificationhandlercodehere
}
信号量的使用特点使其更适用于对Socket（套接字程序中线程的同步。
例如,网络上的HTTP服务器要对同一时间内访问同一页面的用户数加以限制,这时可以为每一个用户对服务器的页面请求设置一个线程,而页面则是待保护的共享资源,通过使用信号量对线程的同步作用可以确保在任一时刻无论有多少用户对某一页面进行访问,只有不大于设定的最大用户数目的线程能够进行访问,而其他的访问企图则被挂起,只有在有用户退出对此页面的访问后才有可能进入。
程序运行结果
事件（Event
事件对象也可以通过通知操作的方式来保持线程的同步。
并且可以实现不同进程中的线程同步操作。
信号量包含的几个操作原语:
CreateEvent（创建一个信号量
OpenEvent（打开一个事件
SetEvent（回置事件
WaitForSingleObject（等待一个事件
WaitForMultipleObjects（
等待多个事件
WaitForMultipleObjects函数原型:
WaitForMultipleObjects（
INDWORDnCount,//等待句柄数
INCONSTHANDLE*lpHandles,//指向句柄数组
INBOOLbWaitAll,//是否完全等待标志
INDWORDdwMilliseconds//等待时间
参数nCount指定了要等待的内核对象的数目,存放这些内核对象的数组由lpHandles来指向。
fWaitAll对指定的这nCount个内核对象的两种等待方式进行了指定,为TRUE时当所有对象都被通知时函数才会返回,为FALSE则只要其中任何一个得到通知就可以返回。
dwMilliseconds在这里的作用与在WaitForSingleObject（中的作用是完全一致的。
如果等待超时,函数将返回WAIT_TIMEOUT。
//事件数组
HANDLEglobal_Events[2];
//共享资源
charglobal_Array[256];
voidInitializeArray（
{
for（inti=0;i<256;i++
{
global_Array[i]=I;
}
}
UINTGlobal_ThreadOne（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
for（inti=0;i<256;i++
{
global_Array[i]=O;
ptr->SetWindowText（global_Array;
Sleep（10;
}
//回置事件
SetEvent（global_Events[0];
return0;
}
UINTGlobal_ThreadTwo（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
for（inti=0;i<256;i++
{
global_Array[i]=T;
ptr->SetWindowText（global_Array;
Sleep（10;
}
//回置事件
SetEvent（global_Events[1];
return0;
}
UINTGlobal_ThreadThree（LPVOIDpParam
{
CEdit*ptr=（CEdit*pParam;
ptr->SetWindowText（"";
//等待两个事件都被回置
WaitForMultipleObjects（2,global_Events,true,INFINITE;for（inti=0;i<256;i++
{
global_Array[i]=H;
ptr->SetWindowText（global_Array;
Sleep（10;
}
return0;
}
voidCEventDlg:
:
OnBnClickedButtonStart（
{
for（inti=0;i<2;i++
{
//实例化事件
global_Events[i]=CreateEvent（NULL,false,false,NULL;}
CWinThread*ptrOne=AfxBeginThread（Global_ThreadOne,&m_One,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED;
ptrOne->ResumeThread（;
//StartthesecondThread
CWinThread*ptrTwo=AfxBeginThread（Global_ThreadTwo,
&m_Two,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED;
ptrTwo->ResumeThread（;
//StarttheThirdThread
CWinThread*ptrThree=AfxBeginThread（Global_ThreadThree,
&m_Three,
THREAD_PRIORITY_NORMAL,
0,
CREATE_SUSPENDED;
ptrThree->ResumeThread（;
//TODO:
Addyourcontrolnotificationhandlercodehere
}
事件可以实现不同进程中的线程同步操作,并且可以方便的实现多个线程的优先比较等待操作,例如写多个WaitForSingleObject来代替WaitForMultipleObjects从而使编程更加灵活。
程序运行结果
总结:
1.互斥量与临界区的作用非常相似,但互斥量是可以命名的,也就是说它可以跨越进程使用。
所以创建互斥量需要的资源更多,所以如果只为了在进程内部是用的话使用临界区会带来速度上的优势并能够减少资源占用量。
因为互斥量是跨进程的互斥量一旦被创建,就可以通过名字打开它。
2.互斥量（Mutex,信号灯（Semaphore,事件（Event都可以被跨越进程使用来进行同步数据操作,而其他的对象与数据同步操作无关,但对于进程和线程来讲,如果进程和线程在运行状态则为无信号状态,在退出后为有信号状态。
所以可以使用WaitForSingleObject来等待进程和线程退出。
3.通过互斥量可以指定资源被独占的方式使用,但如果有下面一种情况通过互斥量就无法处理,比如现在一位用户购买了一份三个并发访问许可的数据库系统,可以根据用户购买的访问许可数量来决定有多少个线程/进程能同时进行数据库操作,这时候如果利用互斥量就没有办法完成这个要求,信号灯对象可以说是一种资源计数器。
升级会员 