生产者消费者问题操作系统课程设计.docx

生产者消费者问题操作系统课程设计.docx

《生产者消费者问题操作系统课程设计.docx》由会员分享，可在线阅读，更多相关《生产者消费者问题操作系统课程设计.docx（16页珍藏版）》请在冰豆网上搜索。

生产者消费者问题操作系统课程设计

1绪论

生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。

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

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

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

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

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

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

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

1.1实现的功能

生产者-消费者问题是一个经典的进程同步问题，有m个生产者和n个消费者，它们共享可存放k件产品的缓冲区。

生产者进程生产物品，然后将物品放置在一个空缓冲区中，供消费者进程消费。

消费者进程从缓冲区中获得物品，然后释放缓冲区。

当生产者进程生产物品时，如果没有空缓冲区可用，那么生产者进程必须等待消费者线程释放出一个空缓冲区。

当消费者进程消费物品时，如果没有满的缓冲区，那么消费者进程将被阻塞，直到新的物品被生产出来。

1.2PV操作

（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生产者——消费者问题。

2.1要求

假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。

消费者每次从缓冲器内取出一件产品去消费。

禁止生产者将产品放入已满的缓冲器内，禁止消费者从空缓冲器内以产品。

假定缓冲器内可同时存放10件产品。

那么，用PV操作来实现生产者和消费者之间的同步

2.2生产者和消费者两个进程的程序

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等代替。

2.3进程控制块PCB。

为了记录进程执行时的情况，以及进程让出处理器后的状态，断点等信息，每个进程都有一个进程控制块PCB。

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

其中进程的状态有：

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

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

进程名

状态

等待原因

断点

图1进程控制块结构

2.4处理器的模拟。

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

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

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

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

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

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

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

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

2.5程序设计

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

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

各部分程序的功能及相互间的关系由图4至图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

空操作

图2模拟的一组指令

序号

生产者程序

消费者程序

0

produce

P（s2）

1

P（s1）

GET

2

PUT

V（s1）

3

V（s2）

consume

4

goto0

goto0

图3生产者和消费者程序

·初始化程序：

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

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

·处理器调度程序：

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

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

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

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

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

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

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

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

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

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

3设计步骤

3.1课程分析

3.1.1基本原理分析

假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。

消费者每次从缓冲器内取出一件产品去消费。

禁止生产者将产品放入已满的缓冲器内，禁止消费者从空缓冲器内以产品。

假定缓冲器内可同时存放10件产品。

那么，用PV操作来实现生产者和消费者之间的同步

3.1.2流程图

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

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

各部分程序的功能及相互间的关系由图

初始化流程

·初始化程序：

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

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

模拟处理器调度

·处理器调度程序：

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

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

模拟处理器指令执行

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

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

模拟处理器指令执行程序的流程图

模拟PV操作的执行

生产者运行结束”的条件判断，模拟时可以采用人工选择的方法实现。

3.1.3测试程序

#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表示满缓冲区的数量*/

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

producter.state='W';

producter.why='';

producter.dd=0;

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

consumer.state='W';

consumer.why='';

consumer.dd=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（（producter.state=='W'）||（consumer.state=='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（）;

}

3.1.4测试结果分析

5结论

参考文献

1、《操作系统实验教程（Linux版）》潘景昌编著清华大学出版社2010

2、《操作系统原理与Linux系统实验》庞丽萍编著机械工业出版社2011