生产者与消费者算法的实现

实验六信号量

厦门大学软件学院

吴清强

一．实验目的

?加强对进程概念的理解。

?进一步了解并发执行的实质。

?分析进程争用资源的现象，学习解决进程互斥的方法

?了解Linux系统中进程通信的基本原理

二．相关知识

?进程的概念。

?进程与程序的区别。

?进程并发执行的概念。

?进程互斥的概念

?进程通信的基本原理

三．实验内容

?使用信号量实现有限缓冲区的生产者和消费者问题

?使用信号量实现读进程具有优先权的读者和写者问题四．实验环境

?PC + Linux Red Hat操作系统

?GCC

1. 使用信号量实现有限缓冲区的生产

者和消费者问题

一．程序流程图

生产者进程生产流程图

消费者进程消费流程图

二．源代码

1、生产者生产进程函数

DWORD WINAPI Producer(LPVOID lpParameter){

while(true){

for(int j=0;j<4;j++){

if(buffer[j]==0){//找到空缓冲区

if(lock[j]==false){//同步锁为false，可以进行操作

lock[j]=true;//加锁，防止其他线程操作此缓冲区

if(buffer[j]<1){//限定一个缓冲区只能存放一个资源

++buffer[j];//模拟生产资源

cout<<"生产一个资源，放入缓冲区"<

lock[j]=false;//解锁

break;//一次生产一个

}

}

if(j==3){

cout<<"找不到空缓冲区，等待中。。"<

Sleep(2000);

}

}

}

}

return 0;

}

2、消费者消费进程函数

DWORD WINAPI Customer(LPVOID lpParameter)

{

while(true){

for(int n=0;n<4;n++){

if(buffer[n]==1){//找到满缓冲区

if(lock[n]==false){//同步锁为false，可以进行操作

lock[n]=true;//加锁，防止其他线程操作此缓冲区

if(buffer[n]>=1){

--buffer[n];//模拟消费资源

cout<<"消费一个资源，从缓冲区"<

lock[n]=false;//解锁

break;//一次生产一个

}

}

}

if(n==3){

cout<<"找不到满缓冲区，等待中。。"<

Sleep(2000);

}}}}

3、主函数，创建5个进程，其中3个生产者进程，2个消费者进程

int main(int argc,char* argv[])

{

HANDLE handle[3];

DWORD dw1,dw2,dw3,dw4,dw5;//创建5个进程

handle[0]=CreateThread(NULL,0,Producer,NULL,0,&dw1);

handle[1]=CreateThread(NULL,0,Producer,NULL,0,&dw2);

handle[2]=CreateThread(NULL,0,Producer,NULL,0,&dw3);

handle[3]=CreateThread(NULL,0,Customer,NULL,0,&dw4);

handle[4]=CreateThread(NULL,0,Customer,NULL,0,&dw5);

}

·三、试验结果

3个生产者2个消费者，共享4个缓冲区，运行结果如下：

1、一个生产者生产，一个消费者消费：

1、两个生产者连续生产，两个消费者连续消费：

2、多个生产者于多个消费者进行生产消费操作：

2.使用信号量实现读进程具有优先权的

读者和写者问题

.

一、程序流程图

二、源代码

#include

#include

#include

#include

#include

#include

int *critical;

int createSem()//创建信号量

{

return semget((key_t)1000,2,IPC_CREAT|0600);

}//the second parameter in semget is the number of signal we will create void initSignal(int semid,int index,int value)//初始化信号量

{

semctl(semid,index,SETV AL,value);

}

void make_critical () //创建缓冲区

{

critical=mmap(NULL,10*sizeof(int),PROT_READ|

PROT_WRITE,MAP_SHARED|

MAP_ANONYMOUS,-1,0);

critical[0]=-1;//the value of the critical file is init as -1

critical[1]=0;//the reader count is 0;

}

void semWait(int semid,int index)//判断当前进程是否进入缓冲区，被占用就挂起

{

struct sembuf sem_buf;

sem_buf.sem_num=index;

sem_buf.sem_op=-1;

sem_buf.sem_flg=SEM_UNDO;

semop(semid,&sem_buf,1);

}

void semSignal(int semid,int index)//唤醒一个在阻塞队列中等待的进程{

struct sembuf sem_buf;

sem_buf.sem_num=index;

sem_buf.sem_op=1;

sem_buf.sem_flg=SEM_UNDO;

semop(semid,&sem_buf,1);

}

//为了让读者优先，当读者获得控制权时，写者进程必须挂起；当第一个读者进程到来（等到写者进程释放控制权）时，第一个读者进程获得优先权，接着其他读者进程不再等待，同时执行。

//故而用critical[1]记录读者进程读到的内容，用semid[0]控制读者或写者进程，用semid[1]更新critical[1]的值

void reader(int semid)

{

while(1)

{

semWait(semid,1);

critical[1]++;

if(critical[1]==1)

semWait(semid,0);

semSignal(semid,1);//correctly update the reader count

printf("reader: read value %d\n",critical[0]);

semWait(semid,1);

critical[1]--;//have read it readers have decreased update it correctly

if(critical[1]==0)//no readers

semSignal(semid,0);//free the ownership of readers

semSignal(semid,1);

}

}

void writer(int semid)

{

while(1)

{

semWait(semid,0);

printf("input:");

scanf("%d",&critical[0]);

printf("writer: write after update value is %d\n",critical[0]);

semSignal(semid,0);

}

}

int main()

{

int semid=createSem();

initSignal(semid,0,1);//初始化控制写者信号量W

initSignal(semid,1,1);//初始化控制读者信号量R

//the critical number is init as -1 the writer will update it

make_critical();//create critical region

pid_t child=fork();

if(child==0)

{

reader(semid);

}

else

{

writer(semid);

}

return 0;

}

三、实验结果：

·五、实验总结

这次多线程的操作系统实验，使我对线程的概念以及多线程程序中线程间的运行有了更深的认识，同时也让我的编程能力得到了一定的提高。

这次做的用多线程实现生产者与消费者模型的实验，由于我的编程能力基础比较差，对线程也是一无所知，所以一开始觉得无从下手，但幸好老师给了充足的时间，我通过看网上找的视频资料以及请教同学才渐渐

地有了一点概念，然后我试着从网上下了一些多线程的程序分析里面的语句，基本弄懂了多线程的原理

附：

#include "iostream.h"

#include "windows.h"

#include "stdio.h"

bool lock[4]={false,false,false,false};//四把锁，分别对四个缓冲区进行同步

int buffer[4]={0,0,0,0};//缓冲区，表示资源的个数

void display(){

cout<<"--------------------------------"<

cout<<"缓冲区0 1 2 3"<

for(int i=0;i<4;i++){cout<<" "<

cout<

}

DWORD WINAPI Producer(LPVOID lpParameter){

while(true){

for(int j=0;j<4;j++){

if(buffer[j]==0){//找到空缓冲区

if(lock[j]==false){//同步锁为false，可以进行操作

lock[j]=true;//加锁，防止其他线程操作此缓冲区

if(buffer[j]<1){//限定一个缓冲区只能存放一个资源

++buffer[j];//模拟生产资源

cout<<"生产一个资源，放入缓冲区"<

lock[j]=false;//解锁

break;//一次生产一个

}

}

if(j==3){

cout<<"找不到空缓冲区，等待中。。"<

Sleep(2000);

}

}

}

}

return 0;

}

DWORD WINAPI Customer(LPVOID lpParameter)

{

while(true){

for(int n=0;n<4;n++){

if(buffer[n]==1){//找到满缓冲区

if(lock[n]==false){//同步锁为false，可以进行操作

lock[n]=true;//加锁，防止其他线程操作此缓冲区

if(buffer[n]>=1){

--buffer[n];//模拟消费资源

cout<<"消费一个资源，从缓冲区"<

lock[n]=false;//解锁

break;//一次生产一个

}

}

}

if(n==3){

cout<<"找不到满缓冲区，等待中。。"<

Sleep(2000);

}

}

}

return 0;

}

int main(int argc,char* argv[])

{

display();

HANDLE handle[3];

DWORD dw1,dw2,dw3,dw4,dw0;

handle[0]=CreateThread(NULL,0,Producer,NULL,0,&dw1);

handle[1]=CreateThread(NULL,0,Producer,NULL,0,&dw2);

handle[2]=CreateThread(NULL,0,Producer,NULL,0,&dw3);

handle[3]=CreateThread(NULL,0,Customer,NULL,0,&dw4);

handle[4]=CreateThread(NULL,0,Customer,NULL,0,&dw0);

display();

Sleep(3000);

display();

return 0;

}