C语言编程模拟生产者和消费者问题.docx

C语言编程模拟生产者和消费者问题.docx

《C语言编程模拟生产者和消费者问题.docx》由会员分享，可在线阅读，更多相关《C语言编程模拟生产者和消费者问题.docx（13页珍藏版）》请在冰豆网上搜索。

C语言编程模拟生产者和消费者问题

实验三编程模拟生产者和消费者问题

一、实验目的和要求

模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。

进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。

我们把若干个进程都能进行访问和修改的那些变量称为公共变量。

由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。

为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。

一般说，同步机构是由若干条原语——同步原语——所组成。

本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。

二、实验环境

Windows操作系统和VisualC++专业版或企业版

三、实验步骤

模拟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;

ifs£0thenR（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。

在模拟实习中，假设进程控制块的结构如图3-1。

其中进程的状态有：

运行态、就绪态、等待态和完成态。

当进程处于等待态时，在进程控制块PCB中要说明进程等待原因（在模拟实习中进程等待原因是为等待信号量s1或s2）；当进程处于等待态或就绪态时，PCB中保留了断点信息，一旦进程再度占有处理器则就从断点位置继续运行；当进程处于完成状态，表示进程执行结束。

进程名

状态

等待原因

断点

图3-1进程控制块结构

（4）处理器的模拟。

计算机硬件提供了一组机器指令，处理器的主要职责是解释执行机器指令。

为了模拟生产者和消费者进程的并发执行，我们必须模拟一组指令和处理职能。

模拟的一组指令见图3-2，其中每条指令的功能由一个过程来实现。

用变量PC来模拟“指令计数器”，假设模拟的指令长度为1，每执行一条模拟指令后，PC加1，提出下一条指令地址。

使用模拟的指令，可把生产者和消费者进程的程序表示为图3-3的形式。

定义两个一维数组PA[0..4]和SA[0..4]，每一个PA[i]存放生产者程序中的一条模拟指令执行的入口地址；每个SA[i]存放消费者程序中的一条模拟指令执行的入口地址。

于是模拟处理器执行一条指令的过程为：

取出PC之值，按PA[PC]或SA[PC]得模拟指令执行的入口地址，将PC之值加1，转向由入口地址确定的相应的过程执行。

模拟的指令

功能

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

空操作

图3-2模拟的处理器指令

序号

生产者程序

消费者程序

0

produce

p（s2）

1

p（s1）

GET

2

PUT

v（s1）

3

v（s2）

consume

4

goto0

goto0

图3-3生产者和消费者程序

（5）程序设计

本实习中的程序由三部分组成：

初始化程序、处理器调度程序、模拟处理器指令执行程序。

各部分程序的功能及相互间的关系由图3-4至图3-7指出。

图3-4初始化流程

图3-5模拟处理器调度

·初始化程序：

模拟实习的程序从初始化程序入口启动，初始化工作包括对信号量s1、s2赋初值，对生产者、消费者进程的PCB初始化。

初始化后转向处理调度程序，其流程如图3-4。

·处理器调度程序：

在计算机系统中，进程并发执行时，任一进程占用处理器执行完一条指令后就有可能被打断而让出处理器由其它进程运行。

故在模拟系统中也类似处理，每当执行一条模拟的指令后，保护当前进程的现场，让它成为非运行态，由处理器调度程序按随机数再选择一个就绪进程占用处理器运行。

处理器调度程序流程见图3-5。

图3-6模拟处理器指令执行

（a）模拟P（s）（b）模拟V（s）

图3-7模拟PV操作的执行

·模拟处理器指令执行程序：

按“指令计数器”PC之值执行指定的指令，且PC加1指向下一条指令。

模拟处理器指令执行程序的流程图见图3-6和图3-7。

另外，为了使得模拟程序有一个结束条件，在图3-6中附加了“生产者运行结束”的条件判断，模拟时可以采用人工选择的方法实现。

图3-7给出了P（s）和V（s）模拟指令执行过程的流程。

其它模拟指令的执行过程已在图3-2中指出。

附录：

代码

#include<>

#include<>

#include<>

#include<>

#defineNULL0

structspcb

{

charname;

charstate;

charwhy;

intdd;

};

typedefstructspcbpcb;

pcbproducter,consumer,*process,*process1;

ints1,s2,i,j,in,out,pc,m;

chararray[10];

charc,x;

intpa[6],sa[6];

intp（ints）/*p操作原语*/

{

s=s-1;

if（s<0）

{

process->state='B';/*B表示阻塞*/

process->why='s';

}

else

{

process->state='W';/*W表示就绪*/

}

return（s）;

}

intv（ints）/*v操作原语*/

{

s=s+1;

if（s<=0）

{

process1->state='W';

}

process->state='W';

return（s）;

}

charRanChar（）

{

chararr[10]={'a','b','c','d','e','f','g','h','i','j'};

returnarr[abs（rand（）%10）];

}

voidput（）

{

//printf（"\npleaseproductanychar!

"）;

//scanf（"\n%c",&c）;

Sleep（1000）;

array[in]=RanChar（）;

in=（in+1）%10;

printf（"productacharis%c!

\n",array[in-1]）;

intk=0;

for（m=0;m<10;m++）

{

if（array[m]!

=''）{

printf（"%c",array[m]）;

k=k+1;

}

}

printf（"缓冲池中有%d个产品\n",k）;

}

voidget（）

{

Sleep（1000）;

x=array[out];

printf（"\n%cgetacharfronbuffer",x）;

printf（"\n"）;

array[out]='';

out=（out+1）%10;

intk=0;

for（m=0;m<10;m++）

{

if（array[m]!

=''）{

printf（"%c",array[m]）;

k=k+1;

}

}

printf（"缓冲池中有%d个产品\n",k）;

}

voidgotol（）

{

pc=0;

}

voidnop（）

{;}

voiddisp（）/*建立进程显示函数,用于显示当前进程*/

{

printf（"\nname\tstate\twhy\tdd\n"）;

printf（"|%c\t",process->name）;

printf（"|%c\t",process->state）;

printf（"|%c\t",process->why）;

printf（"|%d\t",process->dd）;

printf（"\n"）;

}

voidinit（）/*初始化程序*/

{

s1=10;/*s1表示空缓冲区的数量*/

s2=0;/*s2表示满缓冲区的数量*/

='p';/*对生产者进程初始化*/

='W';

='';

=0;

='c';/*对消费者进程初始化*/

='W';

='';

=0;

for（intk=0;k<10;k++）

{

array[k]='';

}

}

voidbornpa（）/*将生产者程序装入pa[]中*/

{

for（i=0;i<=3;i++）

{

pa[i]=i;

}

}

voidbornsa（）/*将消费者程序装入sa[]中*/

{

for（i=0;i<=3;i++）

{

sa[i]=i;

}

}

voiddiaodu（）/*处理器调度程序*/

{

while（=='W'）||=='W'））

{

x=rand（）;/*x随机获得一个数*/

x=x%2;/*对X取于*/

if（x==0）/*若X等于零，则执行生产者进程，反之执行消费者进程*/

{

process=&producter;/*process表示现行进程，将现行进程置为生产者进程*/

process1=&consumer;

}

else

{

process=&consumer;

process1=&producter;

}

pc=process->dd;

i=pc;/*此时把PC的值付给I*/

if（（process->name=='p'）&&（process->state=='W'））

{

j=pa[i];

pc=i+1;

switch（j）

{

case0:

s1=p（s1）;process->dd=pc;break;

case1:

put（）;process->state='W';process->dd=pc;break;

case2:

s2=v（s2）;process->dd=pc;break;

case3:

gotol（）;process->state='W';process->dd=pc;

}

}

elseif（（process->name=='c'）&&（process->state=='W'））/*执行消费者进程且该进程处于就绪状态*/

{

process->state='W';

j=sa[i];

pc=i+1;

switch（j）

{

case0:

s2=p（s2）;process->dd=pc;break;/*申请资源，若没有申请到则跳转*/

case1:

get（）;process->dd=pc;break;

case2:

s1=v（s1）;process->dd=pc;break;

case3:

gotol（）;process->state='W';process->dd=pc;

}

}/*endelse*/

}/*endwhile*/

printf（"\nTheprogramisover!

\n"）;

}

voidmain（）

{

init（）;

bornpa（）;

bornsa（）;

diaodu（）;

}