【译】剖析MFC多线程程序的同步机制

最新推荐文章于 2023-04-04 20:43:27 发布
最新推荐文章于 2023-04-04 20:43:27 发布 · 124 阅读 · 0
文章标签：

#c/c++

本文探讨了多线程编程中的基本同步概念和技术，包括信号量、互斥锁、关键区域和事件等同步对象的使用方法，并通过具体示例展示了如何在MFC中实现线程间的有效同步。
原文链接： Synchronization in Multithreaded Applications with MFC

简介

本文探讨基本的同步概念，并实际动手帮助新手掌握多线程编程。本文的重点在各种同步技巧。

基本概念

在线程执行过程中，或多或少都需要彼此交互，这种交互行为有多种形式和类型。例如，一个线程在执行完它被赋予的任务后，通知另一个线程任务已经完成。然后第二个线程做开始剩下的工作。

下述对象是用来支持同步的：

1)信号量

2)互斥锁

3)关键区域

4)事件

每个对象都有不同的目的和用途，但基本目的都是支持同步。当然还有其他可以用来同步的对象，比如进程和线程对象。后两者的使用由程序员决定，比如说判断一个给定进程或线程是否执行完毕为了使用进程和线程对象来进行同步，我们一般使用Wait*函数，在使用这些函数时，你应当知道一个概念，任何被作为同步对象的内核对象（关键区域除外）都处于两种状态之一：通知状态和未通知状态。例如，进程和线程对象，当他们开始执行时处于未通知状态，而当他们执行完毕时处于通知状态，

为了判断一个给定进程或线程是否已经结束，我们必须判断表示其的对象是否处于通知状态，而要达到这样的目的，我们需要使用Wait*函数。

Wait*函数

下面是最简单的Wait*函数：

DWORDWaitForSingleObject
(
HANDLEhHandle,
DWORDdwMilliseconds
);

参数hHandle表示待检查其状态（通知或者未通知）的对象，dwMilliseconds表示调用线程在被检查对象进入其通知状态前应该等待的时间。若对象处于通知状态或指定时间过去了，这个函数返回控制权给调用线程。若dwMilliseconds设置为INIFINITE（值为-1），则调用线程会一直等待直到对象状态变为通知，这有可能使得调用线程永远等待下去，导致“饿死”。

例如，检查指定线程是否正在执行, dwMilliseconds设置为0,是为了让调用线程马上返回。

DWORDdw = WaitForSingleObject(hProcess, 0 );
 switch (dw)
 {
caseWAIT_OBJECT_0:
//theprocesshasexited
break;
caseWAIT_TIMEOUT:
//theprocessisstillexecuting
break;
caseWAIT_FAILED:
//failure
break;
}
下一个 Wait 类函数类似上面的，但它带的是一系列句柄，并且等待其中之一或全部进入已通知状态。

DWORDWaitForMultipleObjects
(
DWORDnCount,
CONSTHANDLE * lpHandles,
BOOLfWaitAll,
DWORDdwMilliseconds
);
参数 nCount 表示待检查的句柄个数， lpHandles 指向句柄数组，若 fWaitAll 为 TRUE, 则等待所有的对象进入已通知状态，若为 FALSE ，则当任何一个对象进入已通知状态时，函数返回。 dwMilliseconds 意义同上。

例如，下面代码判断哪个进程会先结束：

HANDLEh[ 3 ];
h[ 0 ] = hThread1;
h[ 1 ] = hThread2;
h[ 2 ] = hThread3;

DWORDdw = WaitForMultipleObjects( 3 ,h,FALSE, 5000 ); // 任何一个进入已通知就返回
switch (dw)
 {
caseWAIT_FAILED:
//failure
break;
caseWAIT_TIMEOUT:
//noprocessesexitedduring5000ms
break;
caseWAIT_OBJECT_0+0:
//aprocesswithh[0]descriptorhasexited
break;
caseWAIT_OBJECT_0+1:
//aprocesswithh[1]descriptorhasexited
break;
caseWAIT_OBJECT_0+2:
//aprocesswithh[2]descriptorhasexited
break;
}

句柄数组中索引号为 index 的对象进入已通知状态时，函数返回 WAIT_OBJECT_0 + 索引号。若 fWaitAll 为 TRUE ，则当所有对象进入已通知状态时，函数返回 WAIT_OBJECT_0 。

一个线程若调用一个Wait*函数，则它从用户模式切换为内核模式。这带来的后果有好有坏。不好的是切换进入内核模式大概需要1000个时钟周期，这消耗不算小。好的是当进入内核模式后，就不需要使用处理器，而是进入休眠态，不参与处理器的调度了。

现在让我们进入MFC，并看看它能为我们做些什么。这里有两个类封装了对Wait*函数的调用: CSingleLock和CMultiLock。

同步对象

等价的C++类

Events

CEvent

Critical sections

CCriticalSection

Mutexes

CMutex

Semaphores

CSemaphore

每个类都从一个类--CSyncObject继承下来，此类最有用的成员是重载的HANDLE运算符，它返回指定同步对象的内在句柄。所有这些类都定义在<AfxMt.h>头文件中。

事件

一般来说，事件用于这样的情形下：当指定的动作发生后，一个线程（或多个线程）才开始执行其任务。例如，一个线程可能等待必需的数据收集完后才开始将其保存到硬盘上。有两种事件：手动重置型和自动重置型。通过使用事件，我们可以轻松地通知另一个线程特定的动作已经发生了。对于手动重置型事件，线程使用它通知多个线程特定动作已经发生，而对于自动重置型事件，线程使用它只可以通知一个线程。在MFC中，CEvent类封装了事件对象（若在win32中，它是用一个HANDLE来表示的）。CEvent的构造函数运行我们选择创建手动重置型和自动重置型事件。默认的创建类型是自动重置型事件。为了通知正在等待的线程，我们可以调用CEvent::SetEvent方法，这个方法将会让事件进入已通知状态。若事件是手动重置型，则事件会保持已通知状态，直到对应的CEvent::ResetEvent被调用，这个方法将使得事件进入未通知状态。这个特性使得一个线程可以通过一个SetEvent调用去通知多个线程。若事件是自动重置型，则所有正在等待的线程中只有一个线程会接收到通知。当那个线程接收到通知后，事件会自动进入未通知状态。

下面两个例子将展示上述特性：

// createanauto-resetevent

CEventg_eventStart;

UINTThreadProc1(LPVOIDpParam)
 {
::WaitForSingleObject(g_eventStart,INFINITE);

return0;
}
UINTThreadProc2(LPVOIDpParam)
 {
::WaitForSingleObject(g_eventStart,INFINITE);


return0;
}
在这个例子中，一个全局的 CEvent 对象被创建，当然它是自动重置型的。除此以外，有两个工作线程在等待这个事件对象以便开始其工作。只要第三个线程调用那个事件对象的 SetEvent 方法，则两个线程中之一（当然没人知道会是哪个）会接收到通知，然后事件会进入未通知状态，这就防止了第二个线程也得到事件的通知。

下面来看第二个例子:

// createamanual-resetevent

CEventg_eventStart(FALSE,TRUE);

UINTThreadProc1(LPVOIDpParam)
 {
::WaitForSingleObject(g_eventStart,INFINITE);

return0;
}

UINTThreadProc2(LPVOIDpParam)
 {
::WaitForSingleObject(g_eventStart,INFINITE);

return0;
}
这段代码和上面的稍有不同， CEvent 对象构造函数的参数不一样了，但意义上就大不同了，这是一个手动重置型事件对象。若第三个线程调用事件对象的 SetEvent 方法，则可以确保两个工作线程都会同时（几乎是同时）开始工作。这是因为手动重置型事件在进入已通知状态后，会保持此状态直到对应的 ResetEvent 被调用。

除此以外事件对象还有一个方法：CEvent::PulseEvent。这个方法首先使得事件对象进入已通知状态，然后使其退回到未通知状态。若事件是手动重置型，事件进入已通知状态会让所有正在等待的线程得到通知，然后事件进入未通知状态。若事件是自动重置型，事件进入已通知状态时只会让所有等待的线程之一得到通知。若没有线程在等待，则调用ResetEvent什么也不干。

实例---工作者线程

本文所带的例子中，作者将展示如何创建工作者线程以及如何合理地销毁它们。作者定义了一个被所有线程使用的控制函数。当点击视图区域时，就创建一个线程。所有被创建的线程使用上述控制函数在视图客户区绘制一个运动的圆形。这里作者使用了一个手动重置型事件，它被用来通知所有工作线程其“死讯”。除此以外，我们将看到如何使得主线程等待直到所有工作者线程销毁掉。

作者将线程函数定义为全局的:

struct THREADINFO
 {
HWNDhWnd;//主视图区
POINTpoint;//起始点
} ;

UINTThreadDraw(PVOIDpParam);

 extern CEventg_eventEnd;

UINTThreadDraw(PVOIDpParam)
 {
staticintsnCount=0;//线程计数器
snCount++;//计数器递增
TRACE(TEXT("-ThreadDraw%d:started/n"),snCount);

//取出传入的参数
THREADINFO*pInfo=reinterpret_cast<THREADINFO*>(pParam);

CWnd*pWnd=CWnd::FromHandle(pInfo->hWnd);//主视图区

CClientDCdc(pWnd);

intx=pInfo->point.x;
inty=pInfo->point.y;

srand((UINT)time(NULL));
CRectrectEllipse(x-25,y-25,x+25,y+25);

CSizesizeOffset(1,1);
//刷子颜色随机
CBrushbrush(RGB(rand()%256,rand()%256,rand()%256));
CBrush*pOld=dc.SelectObject(&brush);

while(WAIT_TIMEOUT==::WaitForSingleObject(g_eventEnd,0))
{//只要主线程还未通知我自杀，继续工作!(注意时间设置为)
CRectrectClient;
pWnd->GetClientRect(rectClient);

if(rectEllipse.left<rectClient.left||rectEllipse.right>rectClient.right)
sizeOffset.cx*=-1;

if(rectEllipse.top<rectClient.top||rectEllipse.bottom>rectClient.bottom)
sizeOffset.cy*=-1;

dc.FillRect(rectEllipse,CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH)));

rectEllipse.OffsetRect(sizeOffset);

dc.Ellipse(rectEllipse);
Sleep(25);//休眠下，给其他绘制子线程运行的机会
}

dc.SelectObject(pOld);

deletepInfo;//删除参数，防止内存泄露

TRACE(TEXT("-ThreadDraw%d:exiting./n"),snCount--);//归还计数器
return0;
}
注意作者传入的是一个安全句柄，而不是一个 CWnd 指针，并且在线程函数中通过传入的句柄创建一个临时的 C++ 对象并使用。这样就避免了在多线程编程中多个对象引用单个 C++ 对象的危险。
CArray < CWinThread * ,CWinThread *> m_ThreadArray; // 保存CWinThread对象指针


 // manual-resetevent
CEventg_eventEnd(FALSE,TRUE);

 void CWorkerThreadsView::OnLButtonDown(UINTnFlags,CPointpoint)
 {
THREADINFO*pInfo=newTHREADINFO;//线程参数
pInfo->hWnd=GetSafeHwnd();//视图窗口
pInfo->point=point;//当前点
//将界面作为参数传入线程中，就可以在线程中自己更新主界面,而不用去通知主线程更新界面
CWinThread*pThread=AfxBeginThread(ThreadDraw,(PVOID)pInfo,THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);//创建线程，初始状态为挂起
pThread->m_bAutoDelete=FALSE;//线程执行完毕后不自动销毁
pThread->ResumeThread();//线程开始执行
m_ThreadArray.Add(pThread);//保存创建的线程
}
为了合理地销毁所有线程，首先使得事件进入已通知状态，这会通知工作线程“死期已至”，然后调用 WaitForSingleObject 让主线程等待所有的工作者线程完全销毁掉。注意每次迭代时调用 WaitForSingleObject 会导致从用户模式进入内核模式。例如， 10 此迭代会浪费掉大约 10000 次时钟周期。为了避免这个问题，我们可以使用 WaitForMultipleObjects 。这就是第二种方法。


 void CWorkerThreadsView::OnDestroy()
 {
g_eventEnd.SetEvent();

/**//*//第一种方式
for(intj=0;j<m_ThreadArray.GetSize();j++)
{
::WaitForSingleObject(m_ThreadArray[j]->m_hThread,INFINITE);
deletem_ThreadArray[j];
}
*/
//第二种方式
intnSize=m_ThreadArray.GetSize();
HANDLE*p=newHANDLE[nSize];
for(intj=0;j<nSize;j++)
{
p[j]=m_ThreadArray[j]->m_hThread;
}
::WaitForMultipleObjects(nSize,p,TRUE,INFINITE);
for(intj=0;j<nSize;j++)
{
deletem_ThreadArray[j];
}
delete[]p;
TRACE("-CWorkerThreadsView::OnDestroy:finished!/n");
}
关键区域

和其他同步对象不同，除非有需要以外，关键区域工作在用户模式下。若一个线程想运行一个封装在关键区域中的代码，它首先做一个旋转封锁，然后等待特定的时间，它进入内核模式去等待关键区域。实际上，关键区域持有一个旋转计数器和一个信号量，前者用于用户模式的等待，后者用于内核模式的等待（休眠态）。在Win32API中，有一个CRITICAL_SECTION结构体表示关键区域对象。在MFC中，有一个类CCriticalSection。关键区域是这样一段代码，当它被一个线程执行时，必须确保不会被另一个线程中断。

一个简单的例子是多个线程共用一个全局变量：

int g_nVariable = 0 ;

UINTThread_First(LPVOIDpParam)
 {
if(g_nVariable<100)
{

}
return0;
}

UINTThread_Second(LPVOIDpParam)
 {
g_nVariable+=50;

return0;
}

这段代码不是线程安全的，因为没有线程对变量 g_nVariable 是独占使用的。为了解决这个问题，可以如下使用：
CCriticalSectiong_cs;
 int g_nVariable = 0 ;

UINTThread_First(LPVOIDpParam)
 {
g_cs.Lock();
if(g_nVariable<100)
{

}
g_cs.Unlock();
return0;
}

UINTThread_Second(LPVOIDpParam)
 {
g_cs.Lock();
g_nVariable+=20;
g_cs.Unlock();

return0;
}
这里使用了 CCriticalSection 类的两个方法，调用 Lock 函数通知系统下面代码的执行不能被中断，直到相同的线程调用 Unlock 方法。系统会首先检查被系统关键区域封锁的代码是否被另一个线程捕获。若是，则线程等待直到捕获线程释放掉关键区域。

若有多个共享资源需要保护，则最好为每个资源使用一个单独的关键区域。记得要配对使用UnLock和Lock。还有一点是需要防止“死锁”。

class CSomeClass
 {
CCriticalSectionm_cs;
intm_nData1;
intm_nData2;

public:
voidSetData(intnData1,intnData2)
{
m_cs.Lock();
m_nData1=Function(nData1);
m_nData2=Function(nData2);
m_cs.Unlock();
}

intGetResult()
{
m_cs.Lock();
intnResult=Function(m_nData1,m_nData2);
m_cs.Unlock();
returnnResult;
}
} ;

互斥锁

和关键区域类似，互斥锁设计为对同步访问共享资源进行保护。互斥锁在内核中实现，因此需要进入内核模式操纵它们。互斥锁不仅能在不同线程之间，也可以在不同进程之间进程同步。要跨进程使用，则互斥锁应该是有名的。MFC中使用CMutex类来操纵互斥锁。可以如下方式使用：

CSingleLocksingleLock( & m_Mutex);
singleLock.Lock(); // trytocapturethesharedresource
if (singleLock.IsLocked()) // wedidit
{
//usethesharedresource
//Afterwedone,letotherthreadsusetheresource
singleLock.Unlock();
}
或者通过Win32函数：
 // trytocapturethesharedresource

::WaitForSingleObject(m_Mutex,INFINITE);

 // usethesharedresource


 // Afterwedone,letotherthreadsusetheresource

::ReleaseMutex(m_Mutex);

我们可以使用互斥锁来限制应用程序的运行实例为一个。可以将如下代码放置到InitInstance函数（或WinMain）中：

HANDLEh = CreateMutex(NULL,FALSE, " MutexUniqueName " );
 if (GetLastError() == ERROR_ALREADY_EXISTS)
 {//互斥锁已经存在
AfxMessageBox("Aninstanceisalreadyrunning.");
return(0);
}

信号量

为了限制使用共享资源的线程数目，我们应该使用信号量。信号量是一个内核对象。它存储了一个计数器变量来跟踪使用共享资源的线程数目。例如，下面代码使用CSemaphore类创建了一个信号量对象，它确保在给定的时间间隔内（由构造函数第一个参数指定）最多只有5个线程能使用共享资源。还假定初始时没有线程获得资源：

CSemaphoreg_Sem( 5 , 5 );

一旦线程访问共享资源，信号量的计数器就减1.若变为0，则接下来对资源的访问会被拒绝，直到有一个持有资源的线程离开（也就是说释放了信号量）。我们可以如下使用：

// Trytousethesharedresource
::WaitForSingleObject(g_Sem,INFINITE);
 // Nowtheuser'scounterofthesemaphorehasdecrementedbyone

 // Usethesharedresource
 // Afterwedone,letotherthreadsusetheresource
::ReleaseSemaphore(g_Sem, 1 ,NULL);
 // Nowtheuser'scounterofthesemaphorehasincrementedbyone

主从线程之间的通信

若主线程想通知从线程一些动作的发生，使用事件对象是很方便的。但反过来却是低效，不方便的。因为这会让主线程停下来等待事件，进而降低了应用程序的响应速度。作者提出的方法是让从线程发自定义消息给父线程。

#define WM_MYMSGWM_USER+1

这只能保证窗口类中唯一，但为了确保整个应用程序中唯一，更为安全的方式是：

#define WM_MYMSGWM_APP+1

afx_msgLRESULTOnMyMessage(WPARAM,LPARAM);

LRESULTCMyWnd::OnMyMessage(WPARAMwParam,LPARAMlParam)
 {
//Anotificationgot

//Dosomething
return0;
}

BEGIN_MESSAGE_MAP(CMyWnd,CWnd)

ON_MESSAGE(WM_MYMSG,OnMyMessage)
END_MESSAGE_MAP()

UINTThreadProc(LPVOIDpParam)
 {
HWNDhWnd=(HWND)pParam;

//notifytheprimarythread'swindow
::PostMessage(hWnd,WM_MYMSG,0,0);
return0;
}

但这个方法有个很大的缺陷--内存泄露，作者没有深入研究，可以参考我这篇文章《浅谈一个线程通信代码的内存泄露及解决方案 》

iteye_5736
关注
C++线程中使用的互斥锁CCriticalSection的详细使用
CyberXZ的博客
09-08 712
本文将介绍如何在C++中使用CCriticalSection互斥锁，并提供相应的源代码示例。当一个线程执行到cs.Lock()时，如果互斥锁已经被其他线程获取，则该线程会被阻塞，直到互斥锁被释放。TryLock方法尝试获取互斥锁，如果互斥锁已经被其他线程获取，则返回失败。在获取互斥锁之前，我们调用Lock方法；需要注意的是，对于每个共享资源，我们都需要使用相同的CCriticalSection对象进行保护。通过合理地使用互斥锁，我们可以确保共享资源的正确访问，提高多线程程序的稳定性和可靠性。
[MFC]MFC同步类总结
超越
05-09 2210
MFC同步类 CCriticalSection临界区：在用户模式工作(遇到加锁等待时会进入内核模式)，使用与保护线程间共享资源，一个线程可以多次Lock不会错。不支持在多进程之间工作。将一段代码置入临界区，只允许最多一个线程进入执行这段代码。一个临界区仅在创建它的进程中有效。CMutex互斥量：在内核模式工作，除支持临界区的功能外，还可以为互斥量命名，以便在多进程中工作。互斥量比临界区耗
剖析MFC多线程程序的同步机制
10-15
剖析MFC多线程程序的同步机制指导书，MFC多线程程序的同步机制
MFC 实现的进程的互斥与同步
06-10
MFC 实现的进程的互斥与同步
MFC多线程程序设计.doc
最新发布
08-28
本文将详细探讨MFC多线程程序设计的相关知识和实现方法。 首先，我们需要明确线程的概念。在计算机术语中，线程是执行线程（thread of execution）的简称，它代表程序中的一个单一顺序控制流。线程是操作系统能够...
MFC多线程同步机制详解与实用技巧
本文将深入剖析MFC（Microsoft Foundation Classes）框架下的多线程同步机制，以便新手更好地理解和掌握这一主题。 首先，我们来了解一下基本的概念。在多线程环境中，线程间的交互可以通过多种方式进行，如信号量...
DuoXianCheng.rar_MFC_MFC多线程_MFC多线程例子_MFC界面线程_mfc 多线程
09-14
标题"**DuoXianCheng.rar_MFC_MFC多线程_MFC多线程例子_MFC界面线程_mfc 多线程**"暗示了我们将会讨论如何在MFC应用程序中实现多线程，特别是涉及到UI（用户界面）线程的管理。 MFC是微软为Windows平台开发的应用...
基于MFC和多线程的udp收发程序
01-10
标题 "基于MFC和多线程的UDP收发程序" 提及了几个关键技术和概念，它们在现代软件开发，特别是Windows应用开发中占有重要地位。本文将深入探讨这些技术及其在程序中的应用。 首先，MFC（Microsoft Foundation ...
C++版 MFC实现多线程同步与互斥模拟
01-15
自己做的MFC实现生产者与消费者的模拟。
MFC下多线程同步机制
06-04 1310
在程序中使用多线程时，一般很少有多个线程能哎q
线程同步的四种方式（MFC线程同步4种方式）
fanwenyuan_fwy的专栏
06-21 1201
 使用互斥对象Mutex实现线程同步 [cpp] view plain copy print? CMutex mutex;               //互斥量对象  int g_data = 0;             //全局资源  static HANDLE  g_ReadHnd;   //读线程句柄  static HANDLE  g_WriteH
synchronized同步锁
李星的博客
05-11 322
同步代码块： synchronized（obj）{ //执行的代码...} //锁指定的某个实例对象 synchronized（this）{ //执行的代码...} //锁调用当前方法的实例对象 synchronized（类名.class）{ //执行的代码...}//锁指定的某个类的类对象 同步实例方法 public synchronizedvoid test(){ //方法...
synchronized同步锁详解
枫柳蝶韵
01-07 4886
<br /><br />1. synchronized 方法：通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如： <br /> 　　public synchronized void accessVal(int newVal); <br /> 　　synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能<br />执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从
MFC线程同步一例
hhhh63的专栏
09-01 207
从用线程那天开始，一直受到线程同步的困扰，变量、数组和指针莫名其妙地被改了，宕机，各种锁加了不少，互相等着，与顺序执行效率差不多，有时会锁死，不知道各位高手是怎么处理的。我这边只能按具体情况分别处理，下面分享最近遇到的一个问题。 D2D1_GEOMETRY_RELATION nLock = !!m_pLockGeometry ? m_pLockGeometry->CompareWithGeometry(*pCar->m_pGeoAGV, mtx2, 100.f) : D2...
MFC 线程同步问题
skdkjxy的专栏
12-02 821
一.事件 可以使用CEvent对象发出通知信号,通知系统是否可以运行等待线程 假设有三个线程Thread1,Thread2,Thread3,一个全局的CEvent 对象oEvent [cpp] view plaincopyprint? CEvent oEvent();//等待于(CEvent oEvent(FALSE,FALSE),即(禁止发信,非手动[自动事件])   CEven
MFC多线程同步
qq_47999510的博客
12-28 2026
MFC提供了多种同步对象，下面我们只介绍最常用的四种： 1、临界区（CCriticalSection） 2、事件（CEvent） 3、互斥量（CMutex） 4、信号量（CSemaphore） 一、临界区 使用CCriticalSection类。是一个用于同步的对象，同一时刻只允许一个线程存取资源或代码区。临界区在控制一次只有一个线程修改数据或其它的控制资源时非常有用。 class CCriticalSection...
MFC多线程互斥锁的使用
phenixyf的专栏
04-04 1329
这是未加互斥锁的情况下，程序中，我们在线程1将n赋值为1并在EDIT1显示；理论上控件上应分别显示1和-1，但实际上，会出现同时显示1，或同时显示-1或显示-1和1的情况。这是由于线程间同时调用同一变量造成的（严格来讲并不是同时，而是比如线程1赋值为1后还没打印出来就被线程2赋值为-1了，所以造成最后打印出来都是-1，其他情况同理）。这样在一个线程的运行周期内，其他线程就无法更改变量。8.修改后编译运行，可以看到使用互斥锁后，程序按预想的形式运行，EDIT1稳定的显示1，EDIT2稳定的显示-1。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值