linuxc生產者消費者_在linux下用c語言實現用多進程同步方法演示「生產者-消費者」問題

⑴ 生產者消費者問題--進程

＃i nclude<stdio.h>
＃i nclude< iostream.h>
＃i nclude< windows.h>
#define BufferSize 15
char Buffer[BufferSize];
int head,tail=0;//Buffer數組下標
int count;//被使用的緩沖區數量
HANDLE hMutex;
HANDLE hNotFullEvent, hNotEmptyEvent;//用來同步生產者和消費者線程
////////緩沖區存儲情況
display(char a[15])
{
int i;
cout<<"緩沖區存儲情況為:"<<endl;
for (i=14;i>=0;i--){
cout<<"\t|----"<<a<<"----|"<<endl;
}
}

//p1
void p1_Procer()
{
int i;
char ch;
char p1[]={'a','A','b','B','c','C','D','d','E','e'};
if(tail<15){
for(i=0;i<10;i++){
while(1) {

WaitForSingleObject(hMutex,INFINITE);
if(count==BufferSize){ //緩沖區滿
ReleaseMutex(hMutex);
//等待直到緩沖區非滿
WaitForSingleObject(hNotFullEvent,INFINITE);
continue;
}
//得到互斥鎖且緩沖區非滿,跳出while循環
break;

}
if (tail>14){
cout<<"緩沖區已滿，不能再存入數據！"<<endl;
ReleaseMutex(hMutex); //結束臨界區
PulseEvent(hNotEmptyEvent); //喚醒消費者線程
}
else{
//得到互斥鎖且緩沖區非滿,開始產生新數據
cout<<"Procer p1:\t"<<p1<<endl;
Buffer[tail]=p1;
//tail=(tail+1)%BufferSize;///存放於緩沖區的位置
display(Buffer);
tail++;
count++;
cout<<"按ENTER繼續...."<<endl;
ch=getchar();
ReleaseMutex(hMutex); //結束臨界區
PulseEvent(hNotEmptyEvent); //喚醒消費者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//p2
void p2_Procer()
{
int i;
char ch;
char p2[]={'0','1','2','3','4','5','6','7','8','9'};
if(tail<15){
for(i=0;i<10;i++){
while(1) {
ch=getchar();
WaitForSingleObject(hMutex,INFINITE);
if(count==BufferSize){ // 緩沖區滿
ReleaseMutex(hMutex);
// 等待直到緩沖區非滿
WaitForSingleObject(hNotFullEvent,INFINITE);
continue;
}
// 得到互斥鎖且緩沖區非滿,跳出while循環
break;
}
if (tail>14){
cout<<"緩沖區已滿，不能再存入數據！程序結束！"<<endl;
ReleaseMutex(hMutex); //結束臨界區
PulseEvent(hNotEmptyEvent); //喚醒消費者線程
}
else{
// 得到互斥鎖且緩沖區非滿,開始產生新數據
cout<<"Procer p2:\t"<<p2<<endl;
Buffer[tail]=p2;
//tail=(tail+1)%BufferSize;
display(Buffer);
tail++;
count++;
cout<<"按ENTER繼續...."<<endl;

ch=getchar();
ReleaseMutex(hMutex); // 結束臨界區
PulseEvent(hNotEmptyEvent); // 喚醒消費者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//p3
void p3_Procer()
{
int i;
char ch;
char p3[]={'!','#','$','%','&','*','+','-','.','/'};
if(tail<15){
for(i=0;i<10;i++){
while(1) {
ch=getchar();
WaitForSingleObject(hMutex,INFINITE);
if(count==BufferSize){ // 緩沖區滿
ReleaseMutex(hMutex);
// 等待直到緩沖區非滿
WaitForSingleObject(hNotFullEvent,INFINITE);
continue;
}
// 得到互斥鎖且緩沖區非滿,跳出while循環
break;
}
if (tail>14){
cout<<"緩沖區已滿，不能再存入數據！程序結束！"<<endl;
ReleaseMutex(hMutex); //結束臨界區
PulseEvent(hNotEmptyEvent); //喚醒消費者線程
}
else{
// 得到互斥鎖且緩沖區非滿,開始產生新數據
cout<<"Procer p3:\t"<<p3<<endl;
Buffer[tail]=p3;
//tail=(tail+1)%BufferSize;
display(Buffer);
tail++;
count++;
cout<<"按ENTER繼續...."<<endl;

ch=getchar();
ReleaseMutex(hMutex); // 結束臨界區
PulseEvent(hNotEmptyEvent); // 喚醒消費者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//c1
void c1_Consumer()
{
int i,j,k;
char result,ch;
while(1){
ch=getchar();
WaitForSingleObject(hMutex,INFINITE);
if(count==0){ // 沒有可以處理的數據
ReleaseMutex(hMutex); // 釋放互斥鎖且等待
// 等待直到緩沖區非空
WaitForSingleObject(hNotEmptyEvent,INFINITE);
}
else {if(Buffer[head]==0) {
cout<<"Consumer 0: 緩沖區的數據已全消費過一次，消費完畢！"<<endl;

ReleaseMutex(hMutex); // 結束臨界區
ExitThread(0);
}
else { // 獲得互斥鎖且緩沖區有數據,開始處理
result=Buffer[head];
if(result>64&&result<70){
result=result+32;
cout<<"Consumer c1:(大寫－>小寫)\t "<<result<<endl;
Buffer[head]='^';// '^'表示數據已被消費
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}

if(result>96&&result<102){
result=result-32;
cout<<"Consumer c1:(小寫－>大寫)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}
if(result>47&&result<58){
cout<<"Consumer c1:(顯示字元)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);}
if(result>32&&result<48){
cout<<"Consumer c1:(用符號列印出菱形) "<<endl;
for(i=1;i<=(9+1)/2;i++)
{
for(j=1;j<=40-i;j++)
cout<<" ";
for(k=1;k<=2*i-1;k++)
cout<<result;
cout<<endl;
}
for(i=1;i<=9/2;i++)
{
for(j=1;j<=40-(9+1)/2+i;j++)
cout<<" ";
for(k=1;k<=9-2*i;k++)
cout<<result;
cout<<endl;
}
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}

head=(head+1)%BufferSize;
count--;
cout<<"按ENTER繼續...."<<endl;

ch=getchar();
ReleaseMutex(hMutex); // 結束臨界區
PulseEvent(hNotFullEvent); // 喚醒生產者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//c2
void c2_Consumer()
{
int i,j,k;
char result,ch;
while(1){
WaitForSingleObject(hMutex,INFINITE);
if(count==0){ // 沒有可以處理的數據
ReleaseMutex(hMutex); // 釋放互斥鎖且等待
// 等待直到緩沖區非空
WaitForSingleObject(hNotEmptyEvent,INFINITE);
}
else {if(Buffer[head]==0) {
cout<<"Consumer 0:緩沖區的數據已全消費過一次，消費完畢！"<<endl;
ReleaseMutex(hMutex); // 結束臨界區
ExitThread(0);
}
else { // 獲得互斥鎖且緩沖區有數據,開始處理
result=Buffer[head];
if(result>64&&result<90){
result=result+32;
cout<<"Consumer c2:(大寫－>小寫)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}

if(result>96&&result<102){
result=result-32;
cout<<"Consumer c2:(小寫－>大寫)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);}
if(result>47&&result<58){
cout<<"Consumed c2:(顯示字元)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);}
if(result>32&&result<48){
cout<<"Consumer c2:(用符號列印出菱形) "<<endl;
for(i=1;i<=(9+1)/2;i++)
{
for(j=1;j<=40-i;j++)
cout<<" ";
for(k=1;k<=2*i-1;k++)
cout<<result;
cout<<endl;
}
for(i=1;i<=9/2;i++)
{
for(j=1;j<=40-(9+1)/2+i;j++)
cout<<" ";
for(k=1;k<=9-2*i;k++)
cout<<result;
cout<<endl;
}
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}

head=(head+1)%BufferSize;
count--;
cout<<"按ENTER繼續...."<<endl;
ch=getchar();
ReleaseMutex(hMutex); // 結束臨界區
PulseEvent(hNotFullEvent); // 喚醒生產者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//c3
void c3_Consumer()
{
int i,j,k;
char result,ch;
while(1){
WaitForSingleObject(hMutex,INFINITE);
if(count==0){ // 沒有可以處理的數據
ReleaseMutex(hMutex); // 釋放互斥鎖且等待
// 等待直到緩沖區非空
WaitForSingleObject(hNotEmptyEvent,INFINITE);
}
else {if(Buffer[head]==0) {
cout<<"Consumer 0: 緩沖區的數據已全消費過一次，消費完畢！"<<endl;
ReleaseMutex(hMutex); // 結束臨界區
ExitThread(0);
}
else { // 獲得互斥鎖且緩沖區有數據,開始處理
result=Buffer[head];
if(result>64&&result<70){
result=result+32;
cout<<"Consumer c3:(大寫－>小寫)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);}

if(result>96&&result<102){
result=result-32;
cout<<"Consumer c3:(小寫－>大寫)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);}
if(result>47&&result<58){
cout<<"Consumer c1:(顯示字元)\t "<<result<<endl;
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}
if(result>32&&result<48){
cout<<"Consumer c3:(用符號列印出菱形) "<<endl;
for(i=1;i<=(7+1)/2;i++)
{
for(j=1;j<=40-i;j++)
cout<<" ";
for(k=1;k<=2*i-1;k++)
cout<<result;
cout<<endl;
}
for(i=1;i<=7/2;i++)
{
for(j=1;j<=40-(7+1)/2+i;j++)
cout<<" ";
for(k=1;k<=7-2*i;k++)
cout<<result;
cout<<endl;
}
Buffer[head]='^';
cout<<"'^'表示數據已被消費"<<endl;
display(Buffer);
}
head=(head+1)%BufferSize;
count--;
cout<<"按ENTER繼續...."<<endl;

ch=getchar();
ReleaseMutex(hMutex); // 結束臨界區
PulseEvent(hNotFullEvent); // 喚醒生產者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//主函數
void main()
{
HANDLE hThreadVector[6];
DWORD ThreadID;
count = 0;
head = 0;
tail = 0;
hMutex=CreateMutex(NULL,FALSE,NULL);
hNotFullEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
hNotEmptyEvent=CreateEvent(NULL,TRUE,FALSE,NULL);
hThreadVector[0]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) p1_Procer,NULL, 0, (LPDWORD)&ThreadID);
hThreadVector[1]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) c1_Consumer,NULL, 0, (LPDWORD)&ThreadID);
hThreadVector[3]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) p2_Procer,NULL, 0, (LPDWORD)&ThreadID);
hThreadVector[4]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) c2_Consumer,NULL, 0, (LPDWORD)&ThreadID);
hThreadVector[5]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) p3_Procer,NULL, 0, (LPDWORD)&ThreadID);
hThreadVector[5]=CreateThread (NULL, 0,(LPTHREAD_START_ROUTINE) c3_Consumer,NULL, 0, (LPDWORD)&ThreadID);
WaitForMultipleObjects(2,hThreadVector,TRUE,INFINITE);
//cout<<"**********************Finish*************************"<<endl;
}

我最近也在學操作系統,PV好麻煩的

⑵ 生產者-消費者」問題用C語言編寫

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<semaphore.h>
#include<pthread.h>

#definePRODUCER10//生產者數量
#defineCONSUMER8//消費者數量
#defineBUFFER20//緩沖區數量

sem_tempty,full;//同步信號量
pthread_mutex_tmutex;//互斥信號量
intbuffer[BUFFER];//緩沖區

intprocer_id=0,consumer_id=0;//生產者消費者ID
intindex_in=0,index_out=0;//生產者消費者存放消費的位置

voidprint()//輸出緩沖區
{
inti;
printf("Buffer:
");
for(i=0;i<20;i++)
{
printf("___");
}
printf("
");
for(i=0;i<20;i++)
printf("|%d|",buffer[i]);
printf("
");
for(i=0;i<20;i++)
{
printf("———");
}
printf("
");
}
void*Procer()//生產者函數
{
intID=++procer_id;

while(1)
{
sleep(3);
sem_wait(&empty);
pthread_mutex_lock(&mutex);
index_in=index_in%BUFFER;

printf("Procer%din%d.
",ID,index_in);
buffer[index_in]=1;//緩沖區置0
print();//輸出緩沖區情況
index_in++;
pthread_mutex_unlock(&mutex);
sem_post(&full);
}
}
void*Consumer()//消費者函數
{
intID=++consumer_id;

while(1)
{
sleep(3);
sem_wait(&full);
pthread_mutex_lock(&mutex);
index_out=index_out%BUFFER;

printf("33[01;34mConsumer%din%d33[0m
",ID,index_out);
buffer[index_out]=0;//緩沖區置0
print();//輸出緩沖區情況
index_out++;
pthread_mutex_unlock(&mutex);
sem_post(&empty);
}
}

intmain()
{
//freopen("text.txt","w",stdout);
intrthread[18],i;
pthread_tprocer[PRODUCER];//生產者
pthread_tconsumer[CONSUMER];//消費者

intsinit1=sem_init(&empty,0,BUFFER);//初始化同步信號量
intsinit2=sem_init(&full,0,0);
intminit=pthread_mutex_init(&mutex,NULL);//初始化互斥信號量
if(sinit1&&sinit2)
{
printf("seminitializefailed/n");
exit(1);
}
if(minit)
{
printf("seminitializefailed/n");
exit(1);
}
for(i=0;i<PRODUCER;i++)//創建生產者線程
{
rthread[i]=pthread_create(&procer[i],NULL,Procer,NULL);
if(rthread[i])
{
printf("procer%dcreatefailed/n",i);
exit(1);
}
}
for(i=0;i<CONSUMER;i++)//創建消費者線程
{
rthread[i]=pthread_create(&consumer[i],NULL,Consumer,NULL);
if(rthread[i])
{
printf("consumer%dcreatefailed/n",i);
exit(1);
}
}
for(i=0;i<PRODUCER;i++)//銷毀生產者線程
{
pthread_join(procer[i],NULL);
}
for(i=0;i<CONSUMER;i++)//銷毀生產者線程
{
pthread_join(consumer[i],NULL);
}
exit(0);
}

⑶ 在linux下,處理生產者消費者問題時,生產者完全可以在完成生產任務之後退出,但為什麼一旦退出就會死機

display(Buffer);
tail++;
count++;
cout<<"按ENTER繼續...."<<endl;
ch=getchar();
ReleaseMutex(hMutex); //結束臨界區
PulseEvent(hNotEmptyEvent); //喚醒消費者線程
}
}
}
}
//////////////////////////////////////////////////////////////////
//p2

⑷ 在Linux下編一個C或C++程序，實現多個生產者與多個消費者通過緩沖區或管道通信。

http://..com/question/328567176.html#here
這里是一個很好的例子。我正在為那個提問者分析，你可以借鑒。

⑸ 編程牛人，江湖救急在linux下用C語言編程實現生產者-消費者問題。

超級簡單的，寫自己的N皇後：

＃包括
詮釋Q [20];
詮釋計數= 0;
無效列印（詮釋n）
{;
計數+ +;
為（i = 1; <=我+ +）
{printf（「請（％d個，％D）「，I，Q []）;
}
printf的（」\ n「）;
}
詮釋廣場（INT I，K） /> {;
J = 1;
（J <K）
{如果（（Q [J] == I）| | ABS（Q [J]-I ）== ABS（JK））返回0;
J + +;
}
返回1;
}
無效皇後（K，詮釋n） BR /> {;
（K> N）
（N）;
其他
{為（i = 1; <= n; i + + ）
（地點（I，K）== 1）
【q [K] = I;
皇後（K +1，N）;
} }
}
廉政的main（）
{N;
scanf的（「％D」，＆N）;
皇後區（1，N）; BR />參考getch（）;
返回0;
}

⑹ 在linux下用c語言實現用多進程同步方法演示「生產者-消費者」問題

這個問題需要的知識主要包括：

1 多進程間進行通信；

2 使用同步信號量（semaphore）和互斥信號量（mutex）進行數據保護。

參考代碼如下，可以參照注釋輔助理解：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>
#include<semaphore.h>
#defineN2//消費者或者生產者的數目
#defineM10//緩沖數目
intin=0;//生產者放置產品的位置
intout=0;//消費者取產品的位置
intbuff[M]={0};//緩沖初始化為0，開始時沒有產品
sem_tempty_sem;//同步信號量，當滿了時阻止生產者放產品
sem_tfull_sem;//同步信號量，當沒產品時阻止消費者消費
pthread_mutex_tmutex;//互斥信號量，一次只有一個線程訪問緩沖
intproct_id=0;//生產者id
intprochase_id=0;//消費者id
/*列印緩沖情況*/
voidprint()
{
	inti;
	for(i=0;i<M;i++)
	printf("%d",buff[i]);
	printf("
");
}
/*生產者方法*/
void*proct()
{
	intid=++proct_id;

	while(1)
	{
	//用sleep的數量可以調節生產和消費的速度，便於觀察
	sleep(1);
	//sleep(1);
	
	sem_wait(&empty_sem);
	pthread_mutex_lock(&mutex);
	
	in=in%M;
	printf("proct%din%d.like:	",id,in);
	
	buff[in]=1;
	print();
	++in;
	
	pthread_mutex_unlock(&mutex);
	sem_post(&full_sem);
	}
}
/*消費者方法*/
void*prochase()
{
	intid=++prochase_id;
	while(1)
	{
	//用sleep的數量可以調節生產和消費的速度，便於觀察
	sleep(1);
	//sleep(1);
	
	sem_wait(&full_sem);
	pthread_mutex_lock(&mutex);
	
	out=out%M;
	printf("prochase%din%d.like:	",id,out);
	
	buff[out]=0;
	print();
	++out;
	
	pthread_mutex_unlock(&mutex);
	sem_post(&empty_sem);
	}
}
intmain()
{
	pthread_tid1[N];
	pthread_tid2[N];
	inti;
	intret[N];

	//初始化同步信號量
	intini1=sem_init(&empty_sem,0,M);
	intini2=sem_init(&full_sem,0,0);
	if(ini1&&ini2!=0)
	{
	printf("seminitfailed
");
	exit(1);
	}
	//初始化互斥信號量
	intini3=pthread_mutex_init(&mutex,NULL);
	if(ini3!=0)
	{
	printf("mutexinitfailed
");
	exit(1);
	}
	//創建N個生產者線程
	for(i=0;i<N;i++)
	{
	ret[i]=pthread_create(&id1[i],NULL,proct,(void*)(&i));
	if(ret[i]!=0)
	{
	printf("proct%dcreationfailed
",i);
	exit(1);
	}
	}
	//創建N個消費者線程
	for(i=0;i<N;i++)
	{
	ret[i]=pthread_create(&id2[i],NULL,prochase,NULL);
	if(ret[i]!=0)
	{
	printf("prochase%dcreationfailed
",i);
	exit(1);
	}
	}
	//銷毀線程
	for(i=0;i<N;i++)
	{
	pthread_join(id1[i],NULL);
	pthread_join(id2[i],NULL);
	}
	exit(0);
}

在Linux下編譯的時候，要在編譯命令中加入選項-lpthread以包含多線程支持。比如存儲的C文件為demo.c,要生成的可執行文件為demo。可以使用命令：

gcc demo.c -o demo -lpthread

程序中為便於觀察，使用了sleep(1);來暫停運行，所以查看輸出的時候可以看到，輸出是每秒列印一次的。

導航:首頁 > 操作系統 > linuxc生產者消費者

linuxc生產者消費者

與linuxc生產者消費者相關的資料