您的位置首页百科知识

生产者消费者问题

Simone 发布于 2023-08-06 09:53:08 633 阅读

生产者消费者问题

的有关信息介绍如下：

问题补充说明：用P、V操作实现多个生产者-消费者问题。测试数据文件包括n+l行测试数据，第一行说明几个临界区，其余n行分别描述创建的n个线程是生产者还是消费者，以及生产产品(或消费产品)的时间。... 用P、V操作实现多个生产者-消费者问题。 测试数据文件包括n+l行测试数据，第一行说明几个临界区，其余n行分别描述创建的n个线程是生产者还是消费者，以及生产产品(或消费产品)的时间。每行测试数据包括几个字段，各字段间用空格分隔。第一字段为一个正整数，表示线程序号。第二字段表示相应线程角色，P表示生产者，C表示消费者。第三字段为一个正数，表示生产产品(或消费产品)的时间。消费者还有几个字段，分别表示此消费者消费哪些生产者(线程号)生产的产品。只有所有对应于一个生产者的所有消费者都访问过某临界区后，此生产者或其他生产者才可以往这个临界区放产品。 下面是一个测试数据文件的例子: 5 1 p 3 2 P 4 3 C 4 1 4 P 2 5 C 3 1 2 6 C 2.1 1 2 4以上是题目。和一般的生产者消费者问题应该有一点不一样吧，主要是“只有所有对应于一个生产者的所有消费者都访问过某临界区后，此生产者或其他生产者才可以往这个临界区放产品。”这句到底要怎么实现？另外vc环境下的话，每一行数据后面那些不等长的部分要怎么读入？拜托不要完整的代码，只是PV操作的也可以。谢谢。 展开

生产者消费者问题

#inclu360问答de<windows.h>

#include<f尔课友stream.h>

#include<stdio.h>

#includ住调太e<string>

#include<conio.h>

//定义一些常量；

//本程序允许的最大西难讨探且院绍凯临界区数；

#def步巴思唱铁物套马反天ineMAX_BUFFER_NUM10

//秒到微秒的乘法因子；

#defineINTE_PER_SEC1000

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

#defineMAX_THREAD_NUM64

//定义一个结构，记录在测试文件中指定的每岁队裂粒统轻理一个线程的参数

structTh息击怕readInfo

{

intserial;//线程序列号

charentity;//是P还是C

doubledelay;//线程导乐草首延迟

intthread_r期北须界胜持哪equest[MAX_THREAD_NUM];//线程请求队列

intn_request;//请求个数

};

//全局变量的定义

//临界区对象的声明,用于管理缓冲区的互斥访问；

CRITICAL_SECTIONPC_Critical[MAX_BUF唱奏临正介判十赶帮料世FER_NUM];

intBu转耐七ffer_Critical[MAX_BUFFER服严不清合顾笔处_NUM];//缓冲区声明，用于存放产品；

HANDLEh_Thread[MAX_THREAD_NUM];//用纪钢于存储每个线程句柄的数组；

ThreadInfoThread_I雨始稳排化nfo[MAX_THREAD_NUM];//线程信息数组；

HANDLEempty_semaphore;//一个信号量；

HANDLEh_mutex;//一个互斥量；

DWORDn_Thread=0;//实际的线程的数目；

DWORDn_Buffer_or_Cr专交面业尔宣效假高议itical;//科船充资周养细错实际的缓冲区或者临界区的数目模势首告者先第完；

HANDLEh_Semaph减置夜孩ore[MAX_THREAD_NUM];//生产者允许消费者开始消费的信号量；

//括判半治讨律草学低生产消费及辅助函数的声明

voidProduce(void*p);

voidConsume(void*p);

boolIfInOtherRequest(int);

intFindProducePositon();

intFindBufferPosition(int);

intmain(void)

{

//声明所需变量；

DWORDwait_for_all;

ifstreaminFile;

//初始化缓冲区；

for(inti=0;i<MAX_BUFFER_NUM;i++)

Buffer_Critical[i]=-1;

//初始化每个线程的请求队列；

for(intj=0;j<MAX_THREAD_NUM;j++){

for(intk=0;k<MAX_THREAD_NUM;k++)

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

Thread_Info[j].n_request=0;

}

//初始化临界区；

for(i=0;i<MAX_BUFFER_NUM;i++)

InitializeCriticalSection(&PC_Critical[i]);

//打开输入文件，按照规定的格式提取线程等信息；

***.open("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;

charc;

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++){

intTemp_serial=Thread_Info[j].serial;

charTemp_entity=Thread_Info[j].entity;

doubleTemp_delay=Thread_Info[j].delay;

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

intTemp_request=Thread_Info[j].n_request;

for(intk=0;k<Temp_request;k++)

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

cout<<endl;

}

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");

//下面这个循环用线程的ID号来为相应生产线程的产品读写时所

//使用的同步信号量命名；

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

std::stringlp="semaphore_for_produce_";

inttemp=j;

while(temp){

charc=(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("\n\nALLProducerandconsumerhavefinishedtheirwork.\n");

printf("Pressanykeytoquit!\n");

_getch();

return0;

}

//确认是否还有对同一产品的消费请求未执行；

boolIfInOtherRequest(intreq)

{

for(inti=0;i<n_Thread;i++)

for(intj=0;j<Thread_Info[i].n_request;j++)

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

returnTRUE;

returnFALSE;

}

//找出当前可以进行产品生产的空缓冲区位置；

intFindProducePosition()

{

intEmptyPosition;

for(inti=0;i<n_Buffer_or_Critical;i++)

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

EmptyPosition=i;

//用下面这个特殊值表示本缓冲区正处于被写状态；

Buffer_Critical[i]=-2;

break;

}

returnEmptyPosition;

}

//找出当前所需生产者生产的产品的位置；

intFindBufferPosition(intProPos)

{

intTempPos;

for(inti=0;i<n_Buffer_or_Critical;i++)

if(Buffer_Critical[i]==ProPos){

TempPos=i;

break;

}

returnTempPos;

}

//生产者进程

voidProduce(void*p)

{

//局部变量声明；

DWORDwait_for_semaphore,wait_for_mutex,m_delay;

intm_serial;

//获得本线程的信息；

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

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

Sleep(m_delay);

//开始请求生产

printf("Producer%2dsendstheproducerequire.\n",m_serial);

//确认有空缓冲区可供生产，同时将空位置数empty减1；用于生产者和消费者的同步；

wait_for_semaphore=WaitForSingleObject(empty_semaphore,-1);

//互斥访问下一个可用于生产的空临界区，实现写写互斥；

wait_for_mutex=WaitForSingleObject(h_mutex,-1);

intProducePos=FindProducePosition();

ReleaseMutex(h_mutex);

//生产者在获得自己的空位置并做上标记后，以下的写操作在生产者之间可以并发；

//核心生产步骤中，程序将生产者的ID作为产品编号放入，方便消费者识别;

printf("Producer%2dbegintoproduceatposition%2d.\n",m_serial,ProducePos);

Buffer_Critical[ProducePos]=m_serial;

printf("Producer%2dfinishproducing:\n",m_serial);

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

//使生产者写的缓冲区可以被多个消费者使用，实现读写同步；

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

}

//消费者进程

voidConsume(void*p)

{

//局部变量声明；

DWORDwait_for_semaphore,m_delay;

intm_serial,m_requestNum;//消费者的序列号和请求的数目；

intm_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(inti=0;i<m_requestNum;i++)

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

Sleep(m_delay);

//循环进行所需产品的消费

for(i=0;i<m_requestNum;i++){

//请求消费下一个产品

printf("Consumer%2drequesttoconsume%2dproduct\n",m_serial,m_thread_request[i]);

//如果对应生产者没有生产，则等待；如果生产了,允许的消费者数目-1；实现了读写同步；

wait_for_semaphore=WaitForSingleObject(h_Semaphore[m_thread_request[i]],-1);

//查询所需产品放到缓冲区的号

intBufferPos=FindBufferPosition(m_thread_request[i]);

//开始进行具体缓冲区的消费处理，读和读在该缓冲区上仍然是互斥的；

//进入临界区后执行消费动作；并在完成此次请求后，通知另外的消费者本处请求已

//经满足；同时如果对应的产品使用完毕，就做相应处理；并给出相应动作的界面提

//示；该相应处理指将相应缓冲区清空，并增加代表空缓冲区的信号量；

EnterCriticalSection(&PC_Critical[BufferPos]);

printf("Consumer%2dbegintoconsume%2dproduct\n",m_serial,m_thread_request[i]);

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

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

Buffer_Critical[BufferPos]=-1;//标记缓冲区为空；

printf("Consumer%2dfinishconsuming%2d:\n",m_serial,m_thread_request[i]);

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

ReleaseSemaphore(empty_semaphore,1,NULL);

}

else{

printf("Consumer%2dfinishconsumingproduct%2d\n",m_serial,m_thread_request[i]);

}

//离开临界区

LeaveCriticalSection(&PC_Critical[BufferPos]);

}

}

相关文章
1 消费者保障计划保证金冻结来自在哪里取消
637 阅读