实验一进程同步文档格式.docx

实验一进程同步文档格式.docx

《实验一进程同步文档格式.docx》由会员分享，可在线阅读，更多相关《实验一进程同步文档格式.docx（8页珍藏版）》请在冰豆网上搜索。

系统开辟了一个缓冲区，大小由buffersize指定。

程序中有三个链队列，一个链表。

一个就绪队列（ready），

两个等待队列：

生产者等待队列（producer）;

消费者队列

（consume!

）。

一个链表（over）,用于收集已经运行结束的进程本程序通过函数模拟信号量的原子操作。

2）算法的文字描述：

大致由三个模块组成：

a.主程序（main）：

i.创建信号量、共享内存并进行初始化

ii.创建生产者、消费者进程，生产者执行

pro_fun（），消费者执行con_fun（）

iii.等待所有子进程的结束

iv.删除信号量、共享内存

b.生产者进程（pro_fun）：

i.通过key获得信号量、共享内存的ID，将内存添加到自己的地址空间

ii.P（empty），P（mutex），Add（data），V（mutex），V（full）

iii.解除和共享内存的关联

c.消费者进程（con_fun）：

ii.P（full）,P（mutex）,Add（data）,V（mutex）,

V（empty）

d.循环队列部分：

加入数据：

info[end]=value;

end=（end+1）%3;

取出数据：

temp=info[start];

info[start]=0;

（start=start+1）%3;

returntemp;

3•生产者及消费者解决流程

同步问题：

P进程不能往满的缓冲区放产品，设置信号量empty，初值为0,用于指示空缓冲区数目。

V进程不能从空的缓冲区取产品，设置信号量

full，初值为0,用于知识满缓冲区数目。

解决流程：

P:

V:

Repeat:

repeat:

生产个产品；

p（full）;

送产品到缓冲区；

从缓冲区取产品；

V（full）;

V（empty）;

P（empty）;

消费产品

Untilfalse

untilfalse

生产者进程:

Ppoducei*

3finish

produeingf

■

position[

01:

3

Consiiwei*

4request

tocon&

uiite1product

Ppoducep

2sendstheproduce

require・

Pp&

ducep

2begin

taproduce

atposition

Producer

2finish

producing

positionL

11:

2

Producep

1fiendstheproduce

Fequipft・

1begfin

toproduce

1fin

produeingr

position[

21：

1

Gonsuwer

4begrinto

consune

1pi^oduct

Consutiier

4tinconsunincf

1：

position[

-1

Consumer

tocon^uite3produet

Consuiier

4he^finto

con^utie

3product

Con&

umep

4finishconsult）ing

3:

positinnE

0i:

Consumet*

toconsuiite2ppoduct

ConGUtneF

4beginto

2pFGduct

Consunet*

4finishconsuming

2:

positian[

11:

T

Pressanykeytocontinue

4）实验结果

三.实验源代码

#includevwindows・h>

#includeviostream>

constunsignedshortSIZE_OF_BUFFER=10缓中区长度unsignedshortProductID=0;

//产品号

unsignedshortConsumeID=0;

//将被消耗的产品号

unsignedshortin=0;

unsignedshortout=0;

intg_buffer[SIZE_OF_BUFFER];

boolg_continue=true;

HANDLEg_hMutex;

HANDLEg_hFullSemaphore;

HANDLEg_hEmptySemaphore;

DWORDWINAPIProducer（LPVOID）;

//生产者线程

DWORDWINAPIConsumer（LPVOID）;

//消费者线程

intmain（）

{

//创建各个互斥信号

g_hMutex=CreateMutex（NULL,FALSE,NULL）;

BUFFER-

g_hFullSemaphore

CreateSemaphore（NULL,SIZE_OF_BUFFER-1,SIZE_OF

1,NULL）;

g_hEmptySemaphore

CreateSemaphore（NULL,0,SIZE_OF_BUFFER-1,NULL）;

//总的线程数

constunsignedshortTHREADS_COUNT=PRODUCERS_COUNT+CONSUMERS_COUNT;

HANDLEhThreads[PRODUCERS_COUNT];

//各线程的handle

DWORDproducerID[CONSUMERS_COUNT];

//生产者线程的标识符

DWORDconsumerID[THREADS_COUNT];

//消费者线程的标识符

//创建生产者线程

for（inti=0;

i<

PRODUCERS_COUNT;

++i）{

hThreads[i]=CreateThread（NULL,0,Producer,NULL,0,&

producerID[i]）;

if（hThreads[i]==NULL）return-1;

}

//创建消费者线程

for（i=0;

CONSUMERS_COUNT;

hThreads[PRODUCERS_COUNT+i]=CreateThread（NULL,0,Cons

umer,NULL,0,&

consumerID[i]）;

while（g_continue）{

if（getchar（））{//按回车后终止程序运行

g_continue=false;

return0;

voidProduce（）

std:

:

cerr<

<

"

Producing"

<

++ProductID<

..."

;

Succeed"

std:

endl;

//把新生产的产品放入缓冲区

voidAppend（）

Appendingaproduct..."

g_buffer[in]=ProductID;

in=（in+1）%SIZE_OF_BUFFER;

//输出缓冲区当前的状态

SIZE_OF_BUFFER;

++i）{std:

cout<

i<

"

g_buffer[i];

if（i==in）std:

--生产"

if（i==out）std:

--消费"

//从缓冲区中取出一个产品

voidTake（）

Takingaproduct..."

ConsumeID=g_buffer[out];

out=（out+1）%SIZE_OF_BUFFER;

if（i==out）std:

//消耗一个产品

voidConsume（）

Consuming"

ConsumeID<

//生产者

DWORDWINAPIProducer（LPVOIDlpPara）

WaitForSingleObject（g_hFullSemaphore,INFINITE）;

WaitForSingleObject（g_hMutex,INFINITE）;

Produce（）;

Append（）;

Sleep（1500）;

ReleaseMutex（g_hMutex）;

ReleaseSemaphore（g_hEmptySemaphore,1,NULL）;

//消费者

DWORDWINAPIConsumer（LPVOIDlpPara）

WaitForSingleObject（g_hEmptySemaphore,INFINITE）;

Take（）;

Consume（）;

ReleaseSemaphore（g_hFullSemaphore,1,NULL）;

}return0;