操作系统生产者与消费者问题实验报告

《操作系统》实验报告

生产者和消费者的问题

一、实验目的

1.掌握基本的同步与互斥的算法，理解基本的生产者与消费者的模型。

2.学习使用Windows 2000/XP中基本的同步对象，掌握相关的API的使用方法。

3.了解Windows 2000/XP中多线程的并发执行机制，线程间的同步和互斥。

二、实验的内容及其要求

1.实验内容

以生产者/消费者模型为根据，在Windows 2000环境下创建一个控制台进程，在改进程中创建n个线程模拟生产者和消费者，实现进程（线程）的同步与互斥。

2．实验要求

①学习并理解生产者/消费者模型及其同步/互斥规则

②学习了解Windows同步对象及其特性

③熟悉实验环境，掌握相关API的使用方法

④设计程序，实现生产者/消费者进程（线程）的同步与互斥

⑤提交实验报告

三、实验的时间安排

1．实验前，先到图书馆或上网百度了解有关生产者/消费者模型的相关知识，建立生产者/消费者模型的基本概念。

2．利用13周、15周、17周的上机时间编写和调试程序代码。

3．利用其他课余时间来分析实验的最终结果并完成相关的实验报告。

四、实验的环境

1.硬件条件：普通计算机一台

2.软件条件：①操作系统：Windows 2000/XP

②开发语言：VC++

本实验是在Windows 2000+VC6.0环境下实现的，利用Windows SDK提供的系统接口（API）完成程序的功能。实验在Windows下安装VC后进行，因为VC是一个集成开发环境，其中包含了Windows SDK所有工具和定义，所以安装了VC后就不用特意安装SDK了。实验中所用的API（应用程序接口），是操作系统提供的用来进行应用程序设计的系统功能接口。要使用这些API，需要包含对这些函数进行说明的SDK 头文件，最常见的就是windows.h。一些特殊的API调用还需要包含其他的头文件。

五、正文

1．程序结构图：

2.数据结构：

（1）用一个整型数组Buffer_Critical来代表缓冲区。不管是生产产品还是对已有产品的消费都需要访问改组缓冲区。

（2）在程序中用一个自定义结构ThreadInfo记录一条线程的信息，即将测试用例文件中的一行信息记录下来，用于程序创建相应的生产者或者消费者。由于要创建多个线程，所以程序中使用了一个ThreadInfo结构的数组Thread_Info。

(3)在实现本程序的消费生产模型时，具体地通过如下同步对象实现互斥：

●设一个互斥量h_mutex,以实现生产者在查询和保留缓冲区内的下一个空位置时进行互斥。●每一个生产者用一个信号量与其消费者同步，通过设置h_Semaphore[MAX_THREAD_NUM]信号量数组实现，该组信号量用于表示相应产品已生产。同时用一个表示空缓冲区数目的信号量empty_semaphore进行类似的同步，指示缓冲区中是否存在空位置，以便开始生产下一个产品。

●每一个缓冲区用一个同步对象实现该缓冲区上消费者之间的互斥，这通过设置临界区对象数组PC_Critical[MAX_BUFFER_NUM]实现。

3.实验步骤：

（1）打开VC，选择菜单项File->New，选择Projects选项卡并建立一个名为R_WP1的win32 console application工程，创建时注意指定创建该工程的目录。

（2）在工程中创建源文件R_WP1.cpp：选择菜单项Project->Add to project->Files,此时将打开一个新窗口，在其中的“文件名”输入栏中输入自己想要创建的文件名，这里是R_WP1.cpp；接着询问是否创建新文件时回答“yes”。通过Workspace->Source Files打开该文件，在其中编辑源文件并保存。

（3）通过调用菜单项Build->Rebuild all进行编译连接，可以在指定的工程目录下得到debug->R_WP1.exe

程序，然后把给定的test.txt文件存入该debug目录下，就可以在控制台进入该debug目录运行程序了。需

要强调的是：在创建数据文件时，由于涉及文件的格式问题，最好在记事本中手工逐个输入数据，而不要用复制和粘贴数据。

4.实验源代码：

//*************************R_WP1.cpp***************************

#include

#include

#include

#include

#include

//定义一些常量

//本程序允许的最大临界区数

#define MAX_BUFFER_NUM 10

//秒到微秒的乘法因子

#define INTE_PER_SEC 1000

//本程序允许的生产和消费线程的总数

#define MAX_THREAD_NUM 64

//定义一个结构，记录在测试文件中指定的每一个线程的参数

struct ThreadInfo

{

int serial;

char entity;

double delay;

int thread_request[MAX_THREAD_NUM];

int n_request;

};

CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM];

int Buffer_Critical[MAX_BUFFER_NUM];

HANDLE h_Thread[MAX_BUFFER_NUM];

ThreadInfo Thread_Info[MAX_THREAD_NUM];

HANDLE empty_semaphore;

HANDLE h_mutex;

DWORD n_Thread=0;

DWORD n_Buffer_or_Critical;

HANDLE h_Semaphore[MAX_THREAD_NUM];

void Produce(void *p);

void Consume(void *p);

bool IfInOtherRequest(int);

int FindProducePosition();

int FindBufferPositon(int);

int main(void)

{

DWORD wait_for_all;

ifstream inFile;

for(int i=0;i

Buffer_Critical[i]=-1;

for(int j=0;j

for(int k=0;k

Thread_Info[j].thread_request[k]=-1;

Thread_Info[j].n_request=0;

}

for(i=0;i

InitializeCriticalSection(&PC_Critical[i]);

inFile.open("d:\\test.txt");

inFile>>n_Buffer_or_Critical;

inFile.get();

printf("输出文件是:\n");

printf("%d\n",(int)n_Buffer_or_Critical);

while(inFile){

inFile>>Thread_Info[n_Thread].serial;

inFile>>Thread_Info[n_Thread].entity;

inFile>>Thread_Info[n_Thread].delay;

char c;

inFile.get(c);

while(c!='\n'&&!inFile.eof()){

inFile>>

Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_request++];

inFile.get(c);

}

n_Thread++;

}

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

int Temp_serial=Thread_Info[j].serial;

char Temp_entity=Thread_Info[j].entity;

double Temp_delay=Thread_Info[j].delay;

printf("\n thread%2d %c %f",Temp_serial,Temp_entity,Temp_delay);

int Temp_request=Thread_Info[j].n_request;

for(int k=0;k

printf("%d",Thread_Info[j].thread_request[k]);

cout<

}

printf("\n\n");

empty_semaphore=CreateSemaphore (NULL,n_Buffer_or_Critical,n_Buffer_or_Critical, "semaphore_for_empty");

h_mutex=CreateMutex(NULL,FALSE,"mutex_for_update");

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

std::string lp="semaphore_for_produce_";

int temp=j;

while(temp){

char c=(char)(temp%10);

lp+=c;

temp/=10;

}

h_Semaphore[j+1]=CreateSemaphore(NULL,0,n_Thread,lp.c_str());

}

for(i=0;i<(int)n_Thread;i++){

if(Thread_Info[i].entity=='P')

h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Produce),

&(Thread_Info[i]),0,NULL);

else

h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consume),

&(Thread_Info[i]),0,NULL);

}

wait_for_all=WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);

printf("Press any key to quit!\n");

_getch();

return 0;

}

bool IfInOtherRequest(int req)

{

for(int i=0;i

for(int j=0;j

if(Thread_Info[i].thread_request[j]==req)

return TRUE;

return FALSE;

}

int FindProducePosition()

{

int EmptyPosition;

for(int i=0;i

if(Buffer_Critical[i]==-1){

EmptyPosition=i;

Buffer_Critical[i]=-2;

break;

}

return EmptyPosition;

}

int FindBufferPosition(int ProPos)

{

int TempPos;

for(int i=0;i

if(Buffer_Critical[i]=ProPos){

TempPos=i;

break;

}

return TempPos;

}

void Produce(void *p)

{

DWORD wait_for_semaphore,wait_for_mutex,m_delay;

int m_serial;

m_serial=((ThreadInfo*)(p))->serial;

m_delay=( DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);

Sleep(m_delay);

printf("Producer %2d sends the produce require.\n",m_serial);

wait_for_semaphore=WaitForSingleObject(h_mutex,-1);

int ProducePos=FindProducePosition();

ReleaseMutex(h_mutex);

printf("Producer %2d begin to produce at position %2d.\n",m_serial,

ProducePos);

Buffer_Critical[ProducePos]=m_serial;

printf("Producer %2d finish producing :\n",m_serial);

printf("position[%2d]:%3d\n",ProducePos,Buffer_Critical[ProducePos]);

ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL);

}

void Consume(void *p)

{

DWORD wait_for_semaphore,m_delay;

int m_serial,m_requestNum;

int m_thread_request[MAX_THREAD_NUM];

m_serial=((ThreadInfo*)(p))->serial;

m_delay=(DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);

m_requestNum=((ThreadInfo*)(p))->n_request;

for(int i=0;i

m_thread_request[i]=((ThreadInfo*)(p))->thread_request[i];

Sleep(m_delay);

for(i=0;i

printf("Consumer %2d request to consumer %2d product\n",m_serial,m_thread_request[i]); wait_for_semaphore=WaitForSingleObject(h_Semaphore[m_thread_request[i]],-1);

int BufferPos=FindBufferPosition(m_thread_request[i]);

EnterCriticalSection(&PC_Critical[BufferPos]);

printf("Comsumer %2d begin to consume %2d product \n",m_serial,m_thread_request[i]);

((ThreadInfo*)(p))->thread_request[i]=-1;

if(!IfInOtherRequest(m_thread_request[i])){

Buffer_Critical[BufferPos]=-1;

printf("position [%2d]:%3d\n",BufferPos,Buffer_Critical[BufferPos]);

ReleaseSemaphore(empty_semaphore,1,NULL);

}

else

{

printf("Consumer %2d finish consuming product %2d\n",m_serial,m_thread_request[i]); }

LeaveCriticalSection(&PC_Critical[BufferPos]);

}

}

5.实验运行结果：

其中的实验数据是：

3

1 p 5

2 p 4

3 p 2

4 c 3 1 3 2

6.实验结果分析：

（1）在每个程序中需要先做P，后做V，二者要成对出现，夹在二者中间的代码段就是该进程的临界区。（2）对同步信号量full和empty的P,V操作同样必须成对出现，但它们分别位于不同的程序中。

（3）无论在生产者进程中还是消费者进程中，两个P操作的次序不能颠倒：应先执行同步信号量的P操作，然后执行互斥信号量的P操作。否则可能造成进程死锁。

六、实验总结

1.通过本次实验，了解到生产者/消费者问题是一个经典的进程同步问题，以及在其中使用信号量机制，生产者与消费者问题要求我们设计在同一个进程地址空间内执行的两个线程。

2.通过本次实验，加深了我对操作系统中多线程机制的理解和认识，更让我认识到知识的掌握，仅靠学习理论知识是远远不够的，要与实际动手操作相结合才能更好地理解和分析问题。

3．通过本次实验，发现自己在编程上及一些函数的认识仍存在较大的问题，日后会不断加深各方面知识的学习，弥补自己的不足。