进程同步与互斥Word格式.docx
《进程同步与互斥Word格式.docx》由会员分享，可在线阅读，更多相关《进程同步与互斥Word格式.docx（14页珍藏版）》请在冰豆网上搜索。
lpParamiter——定义一个给进程传递参数的指针。
dwCreationFlags——定义控制线程创建的附加标志。
lpThread——保存线程标志符（32位）
（2）CreateMutex
●功能——创建一个命名或匿名的互斥量对象
HANDLECreateMutex（LPSECURITY_ATTRIBUTESlpMutexAttributes,
BOOLbInitialOwner,
LPCTSTRlpName）;
lpMutexAttributes——必须取值NULL。
bInitialOwner——指示当前线程是否马上拥有该互斥量（即马上加锁）。
lpName——互斥量名称。
（3）CreateSemaphore
●功能——创建一个命名或匿名的信号量对象
HANDLECreateSemaphore（LPSECURITY_ATTRIBUTESlpSemaphoreAttributes,
LONGlInitialCount,
LONGlMaximumCount,
LPCTSTRlpName）;
lpSemaphoreAttributes——必须取值NULL。
lInitialCount——信号量的初始值。
该值大于0，但小于lMaximumCount指定的最大值。
lMaximumCount——信号量的最大值。
lpName——信号量名称。
（4）WaitForSingleObject
●功能——使程序处于等待状态，直到信号量hHandle出现（即其值大于等于1）或超过规定的等待时间
DWORDWaitForSingleObject（HANDLEhHandle,DWORDdwMilliseconds）;
hHandle——信号量指针。
dwMilliseconds——等待的最长时间（INFINITE为无限等待）。
（5）ReleaseSemaphore
●功能——对指定信号量加上一个指定大小的量。
成功执行则返回非0值
BOOLReleaseSemaphore（HANDLEhSemaphore,
LONGlReleaseCount,
LPLONGlppreviousCount）;
hSemaphore——信号量指针。
lReleaseCount——信号量的增量。
lppreviousCount——保存信号量当前值。
（6）ReleaseMutex
●功能——打开互斥锁，即把互斥量加1。
成功调用则返回0
BOOLReleaseMutex（HANDLEhMutex）;
hMutex——互斥量指针。
（7）InitializeCriticalSection
●功能——初始化临界区对象
VOIDInitializeCriticalSection（LPCRITICAL_SECTIONlpCriticalSection）;
lpCriticalSection——指向临界区对象的指针。
（8）EnterCriticalSection
●功能——等待指定临界区对象的所有权
VOIDenterCriticalSection（LPCRITICAL_SECTIONlpCriticalSection）;
（9）LeaveCriticalSection
●功能——释放指定临界区对象的所有权
VOIDLeaveCriticalSection（LPCRITICAL_SECTIONlpCriticalSection）;
四、实验示例（方法、步骤与例程）
1．测试用例文件
测试用例文件用于描述各线程的有关信息，该文件内容及格式如下：
3
1P3
2P4
3C41
4P2
5C3124
说明：
第一行给出的是程序中设置的临界区个数；
其余各行是各进程信息。
每行中的数据之间用Tab键分隔。
第一列（除第一行外）：
线程号。
第二列：
P——生产者，C——消费者。
第三列：
线程在生产和消费前的休眠时间，单位为秒。
第四及以后各列：
消费的产品所对应的生产者线程号。
2．数据结构
（1）用整型数组Buffer_Critical表示缓冲区。
（2）用自定义结构ThreadInfo记录一条线程信息，多个线程对应一个ThreadInfo数组。
（3）通过如下同步对象实现互斥：
●设一个互斥量h-mutex，实现生产者在查询和保留缓冲区的下一个空位置时进行互斥。
●设置h_Semaphore[MAX_THREAD_NUM]信号量数组表示相应产品已经生产，实现生产者与消费者之间的同步。
同时，用表示空缓冲区树木的信号量empty_semephore指示是否存在空位置，实现类似的同步，以便开始下一个产品的生产。
●设置临界区对象数组PC_Critical[MAX_BUFFER_NUM]实现每个缓冲区上消费者之间的互斥。
3．程序结构
为了方便，程序结构用如下的文字予以描述。
（1）主函数
（2）初始化缓冲区、消费请求队列及部分同步对象
（3）提取线程信息
（4）完成线程相关同步对象的初始化
（5）创建线程，模拟生产者和消费者
（6）等待所有线程结束
（7）程序结束
（8）消费者
（9）有无消费请求？
有，则继续（10）；
无，则转（16）
（10）此请求可满足？
可满足，转（11）；
否，则阻塞，再转（10）
（11）确定产品位置
（12）此产品正被消费？
是，则阻塞，再转（12）；
否，则转（13）
（13）进入临界区（请求同一产品的消费者之间互斥）
（14）消费产品，并判断是否应该释放产品所占缓冲区
（15）退出临界区，转（9）
（16）结束消费者线程
（17）生产者
（18）存在空缓冲区？
有，则继续（19）；
无，则阻塞，再转（18）
（19）另一生产者在写？
否，则转（20）；
是，则阻塞，再转（19）
（20）进入临界区（请求同一产品的生产者之间互斥）
（21）在缓冲区中为本线程产品分配空间
（22）退出临界区
（23）写入产品到分配的缓冲区空间中
（24）结束生产者线程
五、参考程序如下：
#include<
windows.h>
fstream.h>
stdio.h>
string>
conio.h>
//定义一些常量
//本程序允许的最大临界区数
#defineMAX_BUFFER_NUM10
//秒到微秒的乘法因子
#defineINTE_PER_SEC1000
//本程序允许的生产和消费线程的总数
#defineMAX_THREAD_NUM64
//定义一个结构，记录在测试文件中指定的每一个线程的参数
structThreadInfo
{
intserial;
//线程序列号
charentity;
//是P还是C
doubledelay;
//线程延迟
intthread_request[MAX_THREAD_NUM];
//线程请求队列
intn_request;
//请求个数
};
//全局变量的定义
//临界区对象的声明,用于管理缓冲区的互斥访问
CRITICAL_SECTIONPC_Critical[MAX_BUFFER_NUM];
intBuffer_Critical[MAX_BUFFER_NUM];
//缓冲区声明，用于存放产品
HANDLEh_Thread[MAX_THREAD_NUM];
//用于存储每个线程句柄的数组
ThreadInfoThread_Info[MAX_THREAD_NUM];
//线程信息数组
HANDLEempty_semaphore;
//一个信号量
HANDLEh_mutex;
//一个互斥量
DWORDn_Thread=0;
//实际的线程的数目
DWORDn_Buffer_or_Critical;
//实际的缓冲区或者临界区的数目
HANDLEh_Semaphore[MAX_THREAD_NUM];
//生产者允许消费者开始消费的信号量
//生产消费及辅助函数的声明
voidProduce（void*p）;
voidConsume（void*p）;
boolIfInOtherRequest（int）;
intFindProducePosition（）;
intFindBufferPosition（int）;
intmain（void）
//声明所需变量
DWORDwait_for_all;
ifstreaminFile;
//初始化缓冲区
for（inti=0;
i<
MAX_BUFFER_NUM;
i++）
Buffer_Critical[i]=-1;
//初始化每个线程的请求队列
for（intj=0;
j<
MAX_THREAD_NUM;
j++）{
for（intk=0;
k<
k++）
Thread_Info[j].thread_request[k]=-1;
Thread_Info[j].n_request=0;
}
//初始化临界段对象
for（i=0;
InitializeCriticalSection（&
PC_Critical[i]）;
//打开输入文件，按照规定的格式提取线程等信息
inFile.open（"
test.txt"
）;
//从文件中获得实际的缓冲区的数目
inFile>
>
n_Buffer_or_Critical;
inFile.get（）;
printf（"
输入文件是:
\n"
//回显获得的缓冲区的数目信息
%d\n"
（int）n_Buffer_or_Critical）;
//提取每个线程的信息到相应数据结构中
while（inFile）{
Thread_Info[n_Thread].serial;
Thread_Info[n_Thread].entity;
Thread_Info[n_Thread].delay;
charc;
inFile.get（c）;
while（c!
='
\n'
&
!
inFile.eof（））{
Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_request++];
n_Thread++;
//回显获得的线程信息，便于确认正确性
for（j=0;
（int）n_Thread;
intTemp_serial=Thread_Info[j].serial;
charTemp_entity=Thread_Info[j].entity;
doubleTemp_delay=Thread_Info[j].delay;
\nthread%2d%c%f"
Temp_serial,Temp_entity,Temp_delay）;
intTemp_request=Thread_Info[j].n_request;
for（intk=0;
Temp_request;
%d"
Thread_Info[j].thread_request[k]）;
cout<
<
endl;
\n\n"
//创建在模拟过程中几个必要的信号量
empty_semaphore=CreateSemaphore（NULL,n_Buffer_or_Critical,n_Buffer_
or_Critical,"
semaphore_for_empty"
h_mutex=CreateMutex（NULL,FALSE,"
mutex_for_update"
//下面这个循环用线程的ID号来为相应生产线程的产品读写时所使用的同步信号量命名
std:
:
stringlp="
semaphore_for_produce_"
;
inttemp=j;
while（temp）{
charc=（char）（temp%10）;
lp+=c;
temp/=10;
h_Semaphore[j+1]=CreateSemaphore（NULL,0,n_Thread,lp.c_str（））;
//创建生产者和消费者线程
i++）{
if（Thread_Info[i].entity=='
P'
）
h_Thread[i]=CreatThread（NULL,0,（LPTHREAD_START_ROUTINE）（Produce）,
（Thread_Info[i]）,0,NULL）
else
h_Thread[i]=CreateThread（NULL,0,（LPTHREAD_START_ROUTINE）（Consume）,
//主程序等待各个线程的动作结束
wait_for_all=WaitForMultipleObjects（n_Thread,h_Thread,TRUE,-1）;
\n\nALLProducerandconsumerhavefinishedtheirwork.\n"
Pressanykeytoquit!
_getch（）;
return0;
//确认是否还有对同一产品的消费请求未执行
boolIfInOtherRequest（intreq）
n_Thread;
Thread_Info[i].n_request;
j++）
if（Thread_Info[i].thread_request[j]==req）
returnTRUE;
returnFALSE;
//找出当前可以进行产品生产的空缓冲区位置
intFindProducePosition（）
intEmptyPosition;
if（Buffer_Critical[i]==-1）{
EmptyPosition=i;
//用下面这个特殊值表示本缓冲区正处于被写状态
Buffer_Critical[i]=-2;
break;
returnEmptyPosition;
//找出当前所需生产者生产的产品的位置
intFindBufferPosition（intProPos）
intTempPos;
if（Buffer_Critical[i]==ProPos）{
TempPos=i;
returnTempPos;
//生产者进程
voidProduce（void*p）
//局部变量声明
DWORDwait_for_semaphore,wait_for_mutex,m_delay;
intm_serial;
//获得本线程的信息
m_serial=（（ThreadInfo*）（p））->
serial;
m_delay=（DWORD）（（（ThreadInfo*）（p））->
delay*INTE_PER_SEC）;
Sleep（m_delay）;
//开始请求生产
Producer%2dsendstheproducerequire.\n"
m_serial）;
//确认有空缓冲区可供生产，同时将空位置数empty减1；
用于生产者和消费者的同步
wait_for_semaphore=WaitForSingleObject（empty_semaphore,-1）;
//互斥访问下一个可用于生产的空临界区，实现写写互斥
wait_for_mutex=WaitForSingleObject（h_mutex,-1）;
intProducePos=FindProducePosition（）;
ReleaseMutex（h_mutex）;
//生产者在获得自己的空位置并做上标记后，以下的写操作在生产者之间可以并发
//在核心生产步骤中，程序将生产者的ID作为产品编号放入，方便消费者识别
Producer%2dbegintoproduceatposition%2d.\n"
m_serial,
ProducePos）;
Buffer_Critical[ProducePos]=m_serial;
Producer%2dfinishproducing:
position[%2d]:
%3d\n"
ProducePos,Buffer_Critical[Produce-
Pos]）;
//使生产者写的缓冲区可以被多个消费者使用，实现读写同步
ReleaseSemaphore（h_Semaphore[m_serial],n_Thread,NULL）;
//消费者进程
voidConsume（void*p）
DWORDwait_for_semaphore,m_delay;
intm_serial,m_requestNum;
//消费者的序列号和请求的数目
intm_thread_request[MAX_THREAD_NUM];
//本消费线程的请求队列
//提取本线程的信息到本地
m_requestNum=（（ThreadInfo*）（p））->
n_request;
m_requestNum;
m_thread_request[i]=（（ThreadInfo*）（p））->
thread_request[i];
//循环进行所需产品的消费
//请求消费下一个产品
Consumer%2drequesttoconsume%2dproduct\n"
m_serial,m_
thread_request[i]）;
//如果对应生产者没有生产，则等待；
//如果生产了,允许的消费者数目为-1；
实现了读写同步
wait_for_semaphore=WaitForSingleObject（h_Semaphore[m_thread_request[i]],-1;
//查询所需产品放到缓冲区的号
intBufferPos=FindBufferPosition（m_thread_request[i]）;
//开始进行具体缓冲区的消费处理，读和读在该缓冲区上仍然是互斥的
//进入临界区后执行消费动作；
并在完成此次请求后，通知另外的消费者本处请求已经满足；
//同时如果对应的产品使用完毕，就做相应处理；
并给出相应动作的界面提示；
//该相应处理指将相应缓冲区清空，并增加代表空缓冲区的信号量
EnterCriticalSection（&
PC_Critical[BufferPos]）;
Consumer%2dbegintoconsume%2dproduct\n"
m_serial,m_thread_
request[i]）;
（（ThreadInfo*）（p））->
thread_request[i]=-1;
if（!
IfInOtherRequest（m_thread_request[i]））{
Buffer_Critical[BufferPos]=-1
升级会员 