实验七同步机构课件.docx
《实验七同步机构课件.docx》由会员分享，可在线阅读，更多相关《实验七同步机构课件.docx（22页珍藏版）》请在冰点文库上搜索。
实验七同步机构课件
实验七：
同步机构实验报告
一、实习内容
模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
二、实习目的
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
三、实习题目
模拟PV操作同步机构，且用PV操作解决生产者——消费者问题。
[提示]：
（1）PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：
P操作原语P（s）：
将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
V操作原语V（s）：
将信号量s加1，若结果不大于0，则释放一个等待信号量s的进程。
这两条原语是如下的两个过程：
procedurep（vars:
semaphore）;
begins:
=s-1;
ifs<0thenW（s）
end{p}
procedurev（vars:
semaphore）;
egins:
=s+1;
ifs0thenR（s）
end{v}
其中W（s）表示将调用过程的进程置为等待信号量s的状态；R（s）表示释放一个等待信号量s的进程。
在系统初始化时应把semaphore定义为某个类型，为简单起见，在模拟实习中可把上述的semaphore直接改成integer。
（2）生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
消费者每次从缓冲器内取出一件产品去消费。
禁止生产者将产品放入已满的缓冲器内，禁止消费者从空缓冲器内以产品。
假定缓冲器内可同时存放10件产品。
那么，用PV操作来实现生产者和消费者之间的同步，生产者和消费者两个进程的程序如下：
B:
array[0..9]ofproducts;
s1,s2;semaphore;
s1:
=10,s2:
=0;
IN,out:
integer;
IN:
=0;out:
=0;
cobegin
procedureproducer;
c:
products;
begin
L1:
Produce（c）;
P（s1）;
B[IN]:
=C;
IN:
=（IN+1）mod10;
V（s2）;
gotoL1
end;
procedureconsumer;
x:
products;
begin
L2:
p（s2）;
x:
=B[out];
out:
=（out+1）mod10;
v（s1）;
consume（x）;
gotoL2
end;
coend.
其中的semaphore和products是预先定义的两个类型，在模拟实现中semaphore用integer代替，products可用integer或char等代替。
（3）进程控制块PCB。
为了记录进程执行时的情况，以及进程让出处理器后的状态，断点等信息，每个进程都有一个进程控制块PCB。
在模拟实习中，假设进程控制块的结构如图12-1。
其中进程的状态有：
运行态、就绪态、等待态和完成态。
当进程处于等待态时，在进程控制块PCB中要说明进程等待原因（在模拟实习中进程等待原因是为等待信号量s1或s2）；当进程处于等待态或就绪态时，PCB中保留了断点信息，一旦进程再度占有处理器则就从断点位置继续运行；当进程处于完成状态，表示进程执行结束。
进程名
状态
等待原因
断点
图12-1进程控制块结构
（4）处理器的模拟。
计算机硬件提供了一组机器指令，处理器的主要职责是解释执行机器指令。
为了模拟生产者和消费者进程的并发执行，我们必须模拟一组指令和处理职能。
模拟的一组指令见图12-2，其中每条指令的功能由一个过程来实现。
用变量PC来模拟“指令计数器”，假设模拟的指令长度为1，每执行一条模拟指令后，PC加1，提出下一条指令地址。
使用模拟的指令，可把生产者和消费者进程的程序表示为图12-3的形式。
定义两个一维数组PA[0..4]和SA[0..4]，每一个PA[i]存放生产者程序中的一条模拟指令执行的入口地址；每个SA[i]存放消费者程序中的一条模拟指令执行的入口地址。
于是模拟处理器执行一条指令的过程为：
取出PC之值，按PA[PC]或SA[PC]得模拟指令执行的入口地址，将PC之值加1，转向由入口地址确定的相应的过程执行。
（5）程序设计
本实习中的程序由三部分组成：
初始化程序、处理器调度程序、模拟处理器指令执行程序。
各部分程序的功能及相互间的关系由图12-4至图12-7指出。
模拟的指令
功能
p（s）
执行P操作原语
v（s）
执行V操作原语
put
B[IN]:
=product;IN:
=（IN+1）mod10
GET
x:
=B[out];out:
=（out+1）mod10
produce
输入一个字符放入C中
consume
打印或显示x中的字符
GOTOL
PC:
=L
NOP
空操作
图12-2模拟的处理器指令
序号
生产者程序
消费者程序
0
produce
p（s2）
1
p（s1）
GET
2
PUT
v（s1）
3
v（s2）
consume
4
goto0
goto0
图12-3生产者和消费者程序
·初始化程序：
模拟实习的程序从初始化程序入口启动，初始化工作包括对信号量s1、s2赋初值，对生产者、消费者进程的PCB初始化。
·处理器调度程序：
在计算机系统中，进程并发执行时，任一进程占用处理器执行完一条指令后就有可能被打断而让出处理器由其它进程运行。
故在模拟系统中也类似处理，每当执行一条模拟的指令后，保护当前进程的现场，让它成为非运行态，由处理器调度程序按随机数再选择一个就绪进程占用处理器运行。
四、实习报告
（1）实习题目。
（2）打印源程序并附上注释。
（3）从键盘上输入一组字符，由生产者每次读入一个字符供消费者输出。
运行模拟程序，打印依次读入的字符和经消费者输出的字符。
（4）把生产者和消费者进程中的P操作、V操作都改成空操作指令，观察在两者不同步的情况下可能出现的与时间有关的错误。
打印依次读入的字符和经消费者输出的字符。
1）实验题目：
模拟PV操作同步机构，且用PV操作解决生产者——消费者问题。
2）实验源代码：
分为四个头文件。
1、a.h头文件代码如下：
#include
#include
#include/*malloc（）等*/
#include/*INT_MAX等*/
#include/*EOF（=^Z或F6）,NULL*/
#include/*atoi（）*/
#include/*eof（）*/
#include/*floor（）,ceil（）,abs（）*/
#include/*exit（）*/
#include
usingnamespacestd;
#include
#defineBUF10//缓存的大小
#defineMAX20//最大可以输入的字符
2、b.h头文件代码如下：
//数据结构的定义和全局变量
typedefstructPcb{
charname[10];//进程名
charstate[10];//运行状态
charreason[10];//若阻塞，其原因
intbreakp;//断点保护
structPcb*next;//阻塞时的顺序
}Pcb,*link;
ints1,s2;//信号量
linkp1;//生产者进程
linkc1;//消费者进程
charstr[MAX];//输入的字符串
charbuffer[BUF];//缓冲池
intlen;//输入长度
intsp=0;//string的指针
intin=0;//生产者指针
intout=0;//消费者指针
chartemp;//供打印的临时产品
charrec_p[MAX];//生产记录
intrp1=0;//生产记录指针
charrec_c[MAX];//消费记录
intrp2=0;//消费记录指针
linkready;//就绪队列
linkb_s1;//s1阻塞队列
linkb_s2;//s2阻塞队列
intpc;//程序计数器
intcount;//字符计数器
intcon_cnt;//消费计数器
3、c.h头文件代码如下：
voidinit（）;//初始化
voidp（ints）;//P操作
voidv（ints）;//V操作
voidblock（ints）;//阻塞函数
voidwakeup（ints）;//唤醒函数
voidcontrol（）;//处理机调度
voidprocessor（）;//处理机执行
voidprint（）;//打印函数
voidinit（）{//初始化
s1=BUF;
s2=0;
p1=（link）malloc（sizeof（Pcb））;//建立新的结点,并初始化为生产者
strcpy（p1->name,"Producer"）;
strcpy（p1->state,"Ready"）;
strcpy（p1->reason,"Null"）;
p1->breakp=0;
p1->next=NULL;
c1=（link）malloc（sizeof（Pcb））;//建立新的结点,并初始化为消费者
strcpy（c1->name,"Consumer"）;
strcpy（c1->state,"Ready"）;
strcpy（c1->reason,"Null"）;
c1->breakp=0;
c1->next=NULL;
ready=p1;
ready->next=c1;//初始化为生产进程在前，消费进程在后
c1->next=NULL;
b_s1=NULL;
b_s2=NULL;//阻塞进程为NULL
pc=0;
con_cnt=0;//消费计数器
}
voidp（ints）{
if（s==1）{//p（s1）
s1--;
if（s1<0）
block
（1）;//阻塞当前生产进程
else{
printf（"\t*s1信号申请成功!
\n"）;
ready->breakp=pc;//保存断点
}
}
else{//p（s2）
s2--;
if（s2<0）
block
（2）;//阻塞当前消费进程
else{
printf（"\t*s2信号申请成功!
\n"）;
ready->breakp=pc;//保存断点
}
}
}
voidv（ints）{
if（s==1）{//v（s1）
s1++;
if（s1<=0）
wakeup
（1）;//唤醒生产进程
ready->breakp=pc;//保存断点
}
else{//v（s2）
s2++;
if（s2<=0）
wakeup
（2）;//唤醒消费进程
ready->breakp=pc;//保存断点
}
}
voidblock（ints）{//阻塞函数的定义
linkp;
intnum1=0;
intnum2=0;
if（s==1）{//生产进程
strcpy（p1->state,"Block"）;//改变状态
strcpy（p1->reason,"S1"）;//说明原因
p=b_s1;
while（p）{
num1++;
p=p->next;//p的值为NULL,表示队尾
}
if（!
b_s1）
b_s1=p1;
else
p=p1;
p1->next=NULL;
printf（"\t*p1生产进程阻塞了!
\n"）;
ready->breakp=pc;//保存断点
ready=ready->next;//在就绪队列中去掉,指向下一个
num1++;
}
else{//消费进程
strcpy（c1->state,"Block"）;
strcpy（c1->reason,"S2"）;
p=b_s2;
while（p）{
num2++;
p=p->next;//p的值为NULL,表示队尾
}
if（!
b_s2）
b_s2=c1;
else
p=c1;
ready->breakp=pc;//保存断点
ready=ready->next;//在就绪队列中去掉,指向下一个
c1->next=NULL;
printf（"\t*c1消费进程阻塞了!
\n"）;
num2++;
}
printf（"\t*阻塞的生产进程个数为:
%d\n",num1）;
printf（"\t*阻塞的消费进程个数为:
%d\n",num2）;
}
voidwakeup（ints）{//唤醒函数的定义
linkp;
linkq=ready;
if（s==1）{//唤醒b_s1队首进程,生产进程队列
p=b_s1;
b_s1=b_s1->next;//阻塞指针指向下一个阻塞进程
strcpy（p->state,"Ready"）;
strcpy（p->reason,"Null"）;
while（q）//插入就绪队列
q=q->next;
q=p;
p->next=NULL;
printf（"\t*p1生产进程唤醒了!
\n"）;
}
else{//唤醒b_s2队首进程,消费进程队列
p=b_s2;
b_s2=b_s2->next;//阻塞指针指向下一个阻塞进程
strcpy（p->state,"Ready"）;
strcpy（p->reason,"Null"）;
while（q->next）//插入就绪队列
q=q->next;
q->next=p;
p->next=NULL;
printf（"\t*c1消费进程唤醒了!
\n"）;
}
}
voidcontrol（）//处理器调度程序
{
intrd;
intnum=0;
linkp=ready;
if（ready==NULL）//若无就绪进程,结束
return;
while（p）//统计就绪进程个数
{
num++;
p=p->next;//最终p变为NULL
}
printf（"\t*就绪进程个数为:
%d\n",num）;
time_tt;
srand（（unsigned）time（&t））;
rd=rand（）%num;//随机函数产生随机数
if（rd==1）{
p=ready;
ready=ready->next;
ready->next=p;
p->next=NULL;
strcpy（ready->state,"Run"）;
strcpy（ready->next->state,"Ready"）;
}
else
strcpy（ready->state,"Run"）;
pc=ready->breakp;
}
voidprocessor（）{//模拟处理器指令执行
if（strcmp（ready->name,"Producer"）==0）//当前进程为生产者
switch（pc）
{
case0:
//produce
printf（"\t*生产者生产了字符%c\n",str[sp]）;
rec_p[rp1]=str[sp];//添加到生产记录
sp=（sp+1）%len;
pc++;
ready->breakp=pc;//保存断点
break;
case1:
//p（s1）
pc++;
p
（1）;
break;
case2:
//put
buffer[in]=rec_p[rp1];//放到缓冲区
printf（"\t*%c字符成功入驻空缓存!
\n",buffer[in]）;
rp1++;
in=（in+1）%BUF;
pc++;
ready->breakp=pc;//保存断点
break;
case3:
//v（s2）
pc++;
printf（"\t*释放一个s2信号\n"）;
v
（2）;
break;
case4:
//goto01
printf（"\t*生产进程goto0操作\n"）;
pc=0;
count--;//剩余字符个数减1
printf（"\t*剩余字符count=%d个\n",count）;
ready->breakp=pc;//保存断点
if（count<=0）{//生产结束
printf（"\t*生产者结束生产!
\n"）;
strcpy（p1->state,"Stop"）;
strcpy（p1->reason,"Null"）;
ready->breakp=-1;
ready=ready->next;//在就绪队列中去掉
}
}
else//当前进程为消费者
switch（pc）
{
case0:
//p（s2）
pc++;
p
（2）;
break;
case1:
//get
printf（"\t*消费者取字符!
\n"）;
temp=buffer[out];
out=（out+1）%BUF;
pc++;
ready->breakp=pc;//保存断点
break;
case2:
//v（s1）
pc++;
printf（"\t*释放一个s1\n"）;
v
（1）;
break;
case3:
//consume
printf（"\t*消费了字符%c\n",temp）;
rec_c[rp2]=temp;//添加到消费记录
rp2++;
con_cnt++;
if（con_cnt>=len）{
strcpy（c1->state,"Stop"）;//完成态
c1->breakp=-1;
return;
}
pc++;
ready->breakp=pc;//保存断点
break;
case4:
//goto0
printf（"\t*消费进程goto0操作\n"）;
pc=0;
ready->breakp=pc;//保存断点
}
}
voidprint（）{
inti,j;
printf（"————————生产者消费者模拟———————\n"）;
printf（"*模拟过程的字符串为:
\t"）;
printf（"%s\n",&str）;
printf（"*已生产:
"）;
for（j=0;j<=rp1;j++）
printf（"%c",rec_p[j]）;
printf（"\n*空缓存:
"）;
for（j=rp2;j<=rp1;j++）
printf（"%c",buffer[j]）;
printf（"\n*已消费:
"）;
for（j=0;j<=rp2;j++）
printf（"%c",rec_c[j]）;
printf（"\n———————进程控制块的信息————————\n"）;
printf（"进程名\t\t状态\t等待原因\t断点\n"）;
printf（"%s\t%s\t%s\t\t%d\n\n",p1->name,p1->state,p1->reason,p1->breakp）;
printf（"%s\t%s\t%s\t\t%d\n",c1->name,c1->state,c1->reason,c1->breakp）;
printf（"———————————————————————\n"）;
printf（"1.继续0.退出\n"）;
scanf（"%d",&i）;
if（i==0）{
exit（0）;
}
}
4、main头文件代码如下：
#include"a.h"
#include"b.h"
#include"c.h"
voidmain（）{
printf（"*生产者消费者模拟\n"）;
printf（"—————————\n"）;
printf（"*请输入字符串:
\n"）;
scanf（"%s",str）;//string数组存放将要产生的字符
len=strlen（str）;
count=len;//输入字符的个数
init（）;//初始化
while（con_cnt{
system（"cls"）;//清屏操作
printf（"—————————模拟指令流程————————\n"）;
control（）;//处理器调度程序
processor（）;//模拟处理器指令执行
print（）;//输出显示各个信息
}
printf（"\n程序结束!
\n"）;
}
3）
升级会员 