#ｄefｉｎｅBUF1０//缓存的大小
#dｅｆineMAX20//最大可以输入的字符
２、b.h头文件代码如下:
／／数据结构的定义和全局变量
ｔypeｄefｓtrｕcｔPcｂ｛
ﻩcｈarnaｍe[10]; //进程名
ﻩcｈarｓｔate[１０];/／运行状态
charｒeａson［１０］;//若阻塞，其原因
iｎt brｅａkp；／/断点保护
ﻩsｔｒｕctPcb*next； ／/阻塞时的顺序
}Pcb,*lｉｎk;
iｎt s1,s2;／/信号量
linkp１；//生产者进程
link c１;／/消费者进程
charsｔｒ[MAＸ］; //输入的字符串
charｂuffer[BUF];//缓冲池
intlｅn;//输入长度
iｎtsp＝0;/／ｓtｒｉｎg的指针
inｔin＝0;／/生产者指针
int ｏuｔ＝０;//消费者指针
chartｅmｐ；／/供打印的临时产品
chaｒ rec_p[MＡX］;／/生产记录
inｔ rp1=０;//生产记录指针
charｒeｃ_c[MAX]；//消费记录
intrｐ2=0;/／消费记录指针
linkｒeady;//就绪队列
link b_s1; /／ｓ１阻塞队列
ｌink b＿s2；//s２阻塞队列
ｉｎt pc;//程序计数器
ｉntｃount;/／字符计数器
ｉntcon_ｃnt;／／消费计数器
3、c.h头文件代码如下：
voidiｎiｔ（）; //初始化
vｏid ｐ（ints）;//P操作
voidv（ｉｎｔs）； //V操作
void block（ints）;／/阻塞函数
ｖoiｄｗaｋeup（iｎts）;//唤醒函数
voｉｄ coｎｔrｏl（）; /／处理机调度
ｖoidproｃessor（）;//处理机执行
vｏidprint（）; ／／打印函数
voiｄｉnit（）{/／初始化
ﻩs１=ＢUF;
s2＝0;
ﻩp1＝（link）malloｃ（sizｅof（Pｃb））;/／建立新的结点,并初始化为生产者
ﻩｓtrcｐy（p1->name,"Ｐrｏducer＂）;
ﻩstｒｃpy（p1-＞ｓｔａｔe,"Reａｄｙ"）;
stｒcpy（p1-＞ｒeaｓon，"Ｎulｌ＂）;
p1－>breａkｐ＝0;
p1->nexｔ=ＮULL;
ﻩc1=（link）malloｃ（sｉｚｅof（Ｐcｂ））;//建立新的结点，并初始化为消费者
ﻩstｒcpy（c1->ｎaｍe,＂Ｃonsumｅr＂）;
ﻩsｔｒｃpy（ｃ1－>ｓｔate,"Rｅａdy"）;
strｃpy（ｃ１-＞reason,"Null"）;
c1->breａｋp＝０;
c1-＞nｅxt=NＵＬL;
ｒeady=p1;
ﻩready->nexｔ=ｃ１;／/初始化为生产进程在前，消费进程在后
ﻩc1->next=NULL；
b_s1=NUＬＬ;
ﻩｂ_s２=NＵＬL；／/阻塞进程为NULL
ﻩpc=０；
ﻩcoｎ_ｃnt=0;//消费计数器
}
voiｄp（inｔs）{
iｆ（s＝=1）{ /／p（s１）
s１--;
ﻩﻩiｆ（s1＜0）
ｂlｏｃk
（1）; //阻塞当前生产进程
ﻩｅｌse{
ﻩﻩﻩprｉｎｔｆ（"\t*s１信号申请成功!
\ｎ"）;
ｒeaｄy－>breａｋp=pｃ; //保存断点
ﻩ}
ﻩ｝
else{／/p（s2）
s２-－;
ﻩﻩif（s２＜０）
ﻩｂloｃｋ
（2）；/／阻塞当前消费进程
ﻩﻩｅlｓe{
ﻩpｒiｎtf（＂\t*s2信号申请成功!
\ｎ"）；
ﻩﻩready-＞brｅakp＝pc;//保存断点
ﻩ｝
ﻩ}
｝
ｖｏｉdv（int ｓ）{
if（s＝=1）{／/ｖ（s１）
ﻩﻩs1+＋;
ﻩﻩiｆ（s１<=0）
ﻩﻩwakｅｕp
（1）;／/唤醒生产进程
ﻩﻩreaｄy－>bｒeakｐ=pc; ／/保存断点
ﻩ}
ﻩelsｅ{/／ｖ（s2）
s２+＋;
ﻩﻩif（s2<=０）
ﻩﻩwakeup
（2）；／/唤醒消费进程
ﻩｒeady->breakp＝pc;//保存断点
ﻩ｝
}
voiｄbｌock（ints）{／／阻塞函数的定义
ﻩｌinｋp;
ﻩｉｎtnum1=0;
intnum２=0;
ﻩｉｆ（s==1）{//生产进程
ﻩﻩsｔrcpｙ（p1->state，"Blocｋ"）;//改变状态
ﻩstrcpy（p1->reaｓon,"S1"）;／/说明原因
ﻩp=b＿s１;
ﻩwhile（p）｛
ﻩﻩnum1++;
ﻩp＝p－>nexｔ；//p的值为ＮＵLL，表示队尾
ﻩ}
if（!
b_ｓ1）
ﻩﻩｂ_ｓ1＝p1；
elsｅ
ｐ＝p１；
ｐ1－>next=NＵLＬ；
ﻩpriｎtf（"\t＊p1生产进程阻塞了!
\n"）；
ﻩﻩready－>ｂreａkp=pc;//保存断点
ﻩﻩrｅaｄｙ=reａdy-＞ｎext；／/在就绪队列中去掉，指向下一个
ﻩﻩnｕm1＋+;
ﻩ｝
ﻩelｓe{//消费进程
ﻩsｔｒcｐy（c1-＞stａte，"Ｂｌｏck"）;
ﻩstrcpｙ（c１->rｅasｏn,"S2"）；
ﻩﻩp=b_s2;
ﻩｗhｉle（ｐ）{
ﻩﻩｎum2++;
ﻩﻩp＝ｐ-＞nｅxt;//p的值为NＵLL，表示队尾
ﻩ}
if（!
b_ｓ2）
ﻩﻩb_s２=ｃ1;
else
ﻩﻩｐ=ｃ1；
ﻩﻩreａdy->ｂreakp=pc;／/保存断点
ﻩﻩreadｙ=ready->nexｔ;//在就绪队列中去掉，指向下一个ﻩﻩ
ﻩﻩc1->nｅxt=NＵLL;
ﻩﻩprｉntｆ（"\t＊c1消费进程阻塞了!
\ｎ"）；
ﻩﻩnｕｍ２＋+；
}ﻩ
pｒintf（"\t*阻塞的生产进程个数为:
%d\n＂,num1）;ﻩ
ﻩpriｎtf（"\t* 阻塞的消费进程个数为:
%d＼n"，ｎum2）;
｝
vｏidwakeｕp（ints）｛//唤醒函数的定义
linkp;
linkq＝ｒeａdy;
if（s==1）{ //唤醒b_s1队首进程,生产进程队列
p＝b_s1;
ﻩﻩｂ_s1=b_s1->next;/／阻塞指针指向下一个阻塞进程
sｔｒｃpｙ（ｐ->ｓｔatｅ,"Ｒｅady"）;
ﻩstｒcpy（p->reasｏｎ,"Nulｌ"）;
ﻩwhile（q）／/插入就绪队列
ﻩﻩq=q->nｅxｔ；
q=ｐ;
ﻩp-＞nｅxt=NUＬL;
ﻩﻩpｒintf（"\t＊p１生产进程唤醒了!
\n"）;
ﻩ}
ﻩelｓe｛ /／唤醒ｂ_s2队首进程，消费进程队列
ﻩp=ｂ_s2;
ﻩb＿ｓ2=b_s2－＞next;／/阻塞指针指向下一个阻塞进程
ﻩsｔｒｃpy（ｐ-＞stａｔe,"Reaｄｙ"）;
ﻩﻩstrcpｙ（p->reason,"Nulｌ"）;
ﻩﻩｗhｉlｅ（q->next）／/插入就绪队列
ﻩq=q->next;
ﻩq->nexｔ=p;
ﻩp->neｘt＝NULL；
ﻩprｉntｆ（"＼t*c1消费进程唤醒了!
\ｎ"）；
}
｝
vｏid conｔrol（） ／/处理器调度程序
{
ﻩiｎtrｄ；
ﻩiｎt ｎum=0;
linkp＝ｒeady;
if（ｒeaｄy==NUＬL） //若无就绪进程,结束
rｅｔurn;
whｉle（p）/／统计就绪进程个数
{
ｎum++；
ﻩｐ=p->ｎｅxt;//最终p变为NULＬ
}
ﻩprintｆ（"\t＊就绪进程个数为：
%ｄ\ｎ＂,ｎum）;
ﻩ
ｔimｅ_ｔ t;
srand（（ｕnsigned）time（&ｔ））;
ﻩrd＝rand（）%num；//随机函数产生随机数
if（rd==１）{
ﻩﻩp=ready;
rｅady＝reaｄy－＞next;
ｒeａdy->nexｔ=p;
ﻩﻩｐ->next=NULL;
ﻩﻩsｔｒｃｐy（reaｄy->state，"Ruｎ＂）;
ｓｔrcｐy（ｒeaｄy->nｅxt->state,"Ｒeadｙ"）;
ﻩ}
else
ﻩﻩｓtrｃpy（rｅａdy->sｔate，＂Run"）；
ﻩpｃ＝readｙ－>bｒeakp；
}
void prｏｃessor（）{ ／/模拟处理器指令执行
ﻩiｆ（strcmp（rｅady->ｎaｍe,"Producer＂）==0）//当前进程为生产者
switｃh（ｐc）
｛
caｓe 0:
//ｐroduｃｅ
ﻩﻩprｉntf（＂\t*生产者生产了字符%c\n＂,str[sp]）;
ﻩｒec_ｐ[rｐ1]=str[sp]；/／添加到生产记录
ﻩ sｐ=（ｓｐ+１）%lｅn；
ﻩﻩｐc++;
ﻩﻩreaｄy->breaｋｐ=pc；/／保存断点
ｂrｅak;
ﻩｃａse1:
／/p（s1）
ﻩｐc++;
ﻩp
（1）；
ﻩﻩﻩｂrｅａk；
ﻩｃasｅ２:
//pｕｔ
ﻩbufｆer[in］=rec_ｐ［rp１］;//放到缓冲区
ﻩﻩprｉntf（"\t*％c字符成功入驻空缓存!
\n",ｂｕffｅr[iｎ]）；
rp1+＋;
ﻩﻩin=（in+1）%ＢUF;
ﻩﻩｐc++；
ﻩﻩｒeady->breaｋp＝ｐc;//保存断点
ﻩﻩbreak;
ﻩcａse3:
／／v（ｓ２）
ﻩﻩﻩpｃ++;
ﻩﻩﻩｐrinｔf（"\ｔ*释放一个s2信号＼n"）;
ﻩｖ
（2）;
ﻩﻩﻩbreak;
ﻩcase4:
//goto０１
ﻩﻩpriｎtｆ（＂＼t* 生产进程ｇoto0操作＼n"）;
ﻩﻩpc=0；
ﻩcｏuｎt－－；／/剩余字符个数减1
ﻩﻩﻩpriｎｔf（＂＼ｔ＊ 剩余字符ｃount=%d个\n＂,counｔ）;
ﻩﻩready->bｒｅakp＝ｐc;//保存断点
ﻩﻩif（count<=0）{ /／生产结束
ﻩﻩｐrintf（"＼t* 生产者结束生产!
\n＂）;
ﻩstrｃｐｙ（p1->sｔate，"Sｔop"）；
ﻩｓｔrcpｙ（p1->rｅason,"Null＂）；
ﻩﻩready->ｂreakp=-1;
ﻩﻩﻩﻩrｅady=ｒeady->ｎｅxt;//在就绪队列中去掉
ﻩﻩ}
}
ﻩelse ／/当前进程为消费者
ﻩﻩｓwitcｈ（pc）
ﻩﻩ｛
ﻩcａｓe0:
//p（ｓ2）
pc++;
ﻩﻩp
（2）;
ﻩﻩbreaｋ;
ﻩｃase １:
//ｇet
ﻩprｉntf（"＼ｔ＊ 消费者取字符！
\ｎ＂）;
ﻩﻩtemｐ＝buffeｒ[out]；
ﻩﻩouｔ=（out+1）％ＢUF;
ﻩﻩpｃ+＋;
ﻩﻩreadｙ->bｒeakp=pc；//保存断点
ﻩﻩbｒeak；
ﻩｃase2:
／／v（s1）
ﻩpc++;
ﻩﻩﻩｐrintf（"\ｔ＊释放一个s１\ｎ"）;
ﻩv
（1）；
ｂrｅak;
ｃaｓe３:
/／consｕｍe
ﻩﻩﻩprｉnｔf（＂\ｔ* 消费了字符％c\n＂，ｔeｍp）；
ﻩﻩrｅc_c［rp２]＝temp;//添加到消费记录
ﻩﻩrp2＋＋;
ﻩcon＿cｎt++;
ﻩﻩﻩｉf（con＿ｃnt>＝len）{
ﻩﻩﻩstrcpy（ｃ１->stａte,＂Stop"）；／/完成态
ﻩﻩc1->ｂｒｅakｐ=-1;
ﻩﻩreturn;
ﻩﻩ｝
ﻩﻩﻩｐc++；
ﻩﻩreaｄy->bｒeakp=ｐc;／/保存断点
ﻩﻩｂｒｅaｋ;
case4:
／/goｔo0
ﻩﻩprｉnｔf（"\t*消费进程ｇoｔo 0操作\n"）;
ﻩﻩpc=0;
ﻩreａdy－>breａｋp=pｃ;／/保存断点
}
}
voｉdpriｎｔ（）{
int ｉ，ｊ;
ｐrintf（"————————生产者消费者模拟———————\n"）;
pｒintf（"*模拟过程的字符串为:
\ｔ＂）;
ﻩpｒｉnｔf（＂%s\n",＆str）;
ﻩ
ﻩprintｆ（"*已生产:
"）;
for（ｊ＝0;ｊ<=rp1;j+＋）
ﻩpｒintf（"%ｃ",rｅc_p［j]）;
prinｔf（"\n* 空缓存：
＂）；
ﻩfor（j=rp2;j<＝rp1;j＋+）
ﻩprintf（"%c＂，bｕfｆer[j]）；
ﻩｐriｎtf（"\ｎ*已消费:
＂）;
foｒ（j=0;j<=rp２;j+＋）
ﻩﻩprintf（"%c＂,rec_ｃ［j]）;
printf（＂\n———————进程控制块的信息————————\ｎ"）;
ﻩprinｔf（＂进程名\t\t状态＼ｔ等待原因\t断点＼ｎ"）;
ﻩpｒinｔｆ（"％s\t%ｓ＼t％s\t＼t%d\ｎ＼n＂,p1－＞ｎamｅ,p1->sｔate，p１-＞reaｓon,ｐ1->ｂｒeakｐ）;
pｒｉｎｔf（"％ｓ\t%ｓ\t%s\t\t％d\n",c1->nａmｅ,c1->state,ｃ1-＞reasｏn,c1->breakｐ）;
printf（"———————————————————————\n＂）;
prｉnｔf（"1.继续０.退出＼n"）；
sｃanｆ（＂%d",&i）;
ｉf（i＝=０）｛
ﻩexiｔ（0）;
}
}
4、main头文件代码如下:
#inclｕdｅ"a．ｈ"
#ｉnclude ＂b.h"
＃inｃｌuｄe "ｃ.ｈ"
ｖoid ｍaiｎ（）{
prinｔf（"*生产者消费者模拟＼n"）；
ﻩprintf（＂—————————\ｎ"）;
ﻩprｉntf（"＊请输入字符串:
\n"）;
scanf（＂%s",str）;//strｉｎｇ数组存放将要产生的字符
ﻩｌen=strlen（stｒ）;
ﻩcoｕｎt=ｌｅn; //输入字符的个数
ｉｎit（）; //初始化
while（con_cｎt＜len）/／消费完所有的字符为结束
{
sysｔeｍ（"cls"）; //清屏操作ﻩ
ﻩpｒintf（"—————————模拟指令流程————————\ｎ"）;
ﻩﻩcontrol（）; //处理器调度程序
ﻩpｒocessor（）; //模拟处理器指令执行
ﻩﻩprｉnt（）; //输出显示各个信息
ﻩ}
ｐrｉｎtf（＂\n程序结束!
＼n"）;
}
六、运行结果截图:
升级会员 