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生产者消费者相关的资料