生产者消费者模式源码（生产者消费者代码实现）
本文目录一览：
- 1、生产者-消费者”问题 用C语言编写
- 2、我想知道我这段java的关于生产者和消费者模式的代码哪里有错？
- 3、怎样用C++实现生产者消费者的模拟
- 4、急求！！多线程生产者消费者问题的c语言程序，要源码、已在linux中执行过的文件，最好有截图！！
- 5、生产者消费者代码
生产者-消费者”问题 用C语言编写
#includestdio.h
#includestdlib.h
#includeunistd.h
#includesemaphore.h
#includepthread.h
#define PRODUCER 10//生产者数量
#define CONSUMER 8//消费者数量
#define BUFFER 20//缓冲区数量
sem_t empty,full;//同步信号量
pthread_mutex_t mutex;//互斥信号量
int buffer[BUFFER]; //缓冲区
int producer_id=0,consumer_id=0;//生产者消费者ID
int index_in=0,index_out=0;//生产者 消费者 存放 消费的位置
void print()//输出缓冲区
{
int i;
printf("Buffer:\n");
for(i=0;i20;i++)
{
printf("___");
}
printf("\n");
for(i=0;i20;i++)
printf("|%d|",buffer[i]);
printf("\n");
for(i=0;i20;i++)
{
printf("———");
}
printf("\n");
}
void *Producer()//生产者函数
{
int ID=++producer_id;
while(1)
{
sleep(3);
sem_wait(empty);
pthread_mutex_lock(mutex);
index_in=index_in%BUFFER;
printf("Producer %d in %d.\n",ID,index_in);
buffer[index_in]=1;//缓冲区置0
print();//输出缓冲区情况
index_in++;
pthread_mutex_unlock(mutex);
sem_post(full);
}
}
void *Consumer()//消费者函数
{
int ID=++consumer_id;
while(1)
{
sleep(3);
sem_wait(full);
pthread_mutex_lock(mutex);
index_out=index_out%BUFFER;
printf("\033[01;34mConsumer %d in %d\033[0m\n",ID,index_out);
buffer[index_out]=0;//缓冲区置0
print();//输出缓冲区情况
index_out++;
pthread_mutex_unlock(mutex);
sem_post(empty);
}
}
int main()
{
//freopen("text.txt","w",stdout);
int rthread[18],i;
pthread_t producer[PRODUCER];//生产者
pthread_t consumer[CONSUMER];//消费者
int sinit1=sem_init(empty,0,BUFFER);//初始化同步信号量
int sinit2=sem_init(full,0,0);
int minit =pthread_mutex_init(mutex,NULL);//初始化互斥信号量
if(sinit1 sinit2)
{
printf("sem initialize failed /n");
exit(1);
}
if(minit)
{
printf("sem initialize failed /n");
exit(1);
}
for(i=0;iPRODUCER;i++)//创建生产者线程
{
rthread[i]=pthread_create(producer[i], NULL, Producer, NULL);
if(rthread[i])
{
printf("producer %d create failed /n", i);
exit(1);
}
}
for(i=0;iCONSUMER;i++)//创建消费者线程
{
rthread[i]=pthread_create(consumer[i], NULL, Consumer,NULL);
if(rthread[i])
{
printf("consumer %d create failed /n", i);
exit(1);
}
}
for(i=0;iPRODUCER;i++)//销毁生产者线程
{
pthread_join(producer[i],NULL);
}
for(i=0;iCONSUMER;i++)//销毁生产者线程
{
pthread_join(consumer[i],NULL);
}
exit(0);
}
我想知道我这段java的关于生产者和消费者模式的代码哪里有错？
你这个里面那个while（flag）有问题，会出现死锁的。
lock.lock()就已经可以保证互斥了，不需要你在增加这个while（flag）的操作。
怎样用C++实现生产者消费者的模拟
// producer_consumer.cpp
//////////////////////////////////////////////////////////////////////
// 有一个生产者在生产产品生产者消费者模式源码，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，
// 在两者之间设置一个有多个缓冲区生产者消费者模式源码的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓
// 冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消
// 费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。
//////////////////////////////////////////////////////////////////////
#include pthread.h
#include stdio.h
#include stdlib.h
#include unistd.h
const int BUFFER_LENGTH = 100;
int buffer[BUFFER_LENGTH];
int front = 0, rear = -1; // 缓冲区的前端和尾端
int size = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void *producer(void *arg);
void *consumer(void *arg);
int main(int argc, char **argv)
{
pthread_t producer_id;
pthread_t consumer_id;
pthread_create(producer_id, NULL, producer, NULL);
pthread_create(consumer_id, NULL, consumer, NULL);
//主线程运行结束，子线程也就运行结束了
//
sleep(1);
return 0;
}
void *producer(void *arg)
{
//pthread_detach(threadid)函数的功能是使线程ID为threadid的线程处于分离状态，一旦线程处于分离状态，
//该线程终止时底 层资源立即被回收；否则终止子线程的状态会一直保存（占用系统资源）直到主线程调用pthread_join(threadid,NULL)获取线程的退 出状态。
//通常是主线程使用pthread_create()创建子线程以后，一般可以调用pthread_detach(threadid)分离刚刚创建的子线程，
//这里的threadid是指子线程的threadid；如此以来，该子线程止时底层资源立即被回收；
//被创建的子线程也可以自己分离自己，子线程调用pthread_detach(pthread_self())就是分离自己，
//因为pthread_self()这个函数返回的就是自己本身的线程ID；
pthread_detach(pthread_self());
while (true)
{
pthread_mutex_lock(mutex);
while (size == BUFFER_LENGTH) // 如果缓冲区已满，等待; 否则，添加新产品
{
printf("buffer is full. producer is waiting...\n");
pthread_cond_wait(cond, mutex);
}
// 往尾端添加一个产品
rear = (rear + 1) % BUFFER_LENGTH;
buffer[rear] = rand() % BUFFER_LENGTH;
printf("producer produces the item %d: %d\n", rear, buffer[rear]);
++size;
if (size == 1) // 如果当前size=1, 说明以前size=0, 消费者在等待，则给消费者发信号
{
pthread_cond_signal(cond);
}
pthread_mutex_unlock(mutex);
}
}
void *consumer(void *arg)
{
pthread_detach(pthread_self());
while (true)
{
pthread_mutex_lock(mutex);
while(size == 0) // 如果缓冲区已空，等待; 否则，消费产品
{
printf("buffer is empty. consumer is waiting...\n");
pthread_cond_wait(cond, mutex);
}
// 从前端消费一个产品
printf("consumer consumes an item%d: %d\n", front, buffer[front]);
front = (front + 1) % BUFFER_LENGTH;
--size;
if (size == BUFFER_LENGTH-1) // 如果当前size=BUFFER_LENGTH-1，说明以前生产者在等待，则给生产者发信号
{
pthread_cond_signal(cond);
}
pthread_mutex_unlock(mutex);
}
}
急求！！多线程生产者消费者问题的c语言程序，要源码、已在linux中执行过的文件，最好有截图！！
#include sys/types.h
#include sys/ipc.h
#include sys/shm.h
#include stdio.h
#include semaphore.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#include stdlib.h
#include unistd.h
#include sys/mman.h
#include sys/time.h
#includestring.h
#define BUFSIZE 4096
#define SEM_IN_TASK "INX_TASK"
#define SEM_OUT_TASK "OUTX_TASK"
sem_t *sem_in;
sem_t *sem_out;
main(int argc, char** argv) // map a normal file as shared mem:
{
int fd,i;
char *p_map;
char temp;
fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);
//lseek(fd,sizeof(people)*5-1,SEEK_SET);
write(fd,"",1);
p_map = (char*) mmap( NULL,BUFSIZE,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 );//建立共享内存
close( fd );
sem_unlink(SEM_IN_TASK);
sem_unlink(SEM_OUT_TASK);
sem_in = sem_open(SEM_IN_TASK,O_CREAT|O_EXCL,0644,1); //1ok
sem_out=sem_open(SEM_OUT_TASK,O_CREAT|O_EXCL,0644,0); //0ok
printf("[sem_in] [%d]\n",sem_in);
printf("[sem_out] [%d]\n",sem_out);
if(sem_in == SEM_FAILED||sem_out == SEM_FAILED)
{
perror("wangsha-unable to create semaphore");
sem_unlink(SEM_IN_TASK);
sem_unlink(SEM_OUT_TASK);
exit(-1);
}
memset(p_map,0,BUFSIZE);
while(1)
{
//printf("---------A waitting B-----------\n\n\n\n");
sem_wait(sem_out);
printf("A:%s\n",p_map );
memset(p_map,'a',100);
sem_post(sem_in);
//printf("------------A emit B-----------\n\n\n\n");
}
munmap( p_map, BUFSIZE );
printf( "umap ok \n" );
}
#include sys/mman.h
#include sys/types.h
#include fcntl.h
#include unistd.h
#include sys/types.h
#include sys/ipc.h
#include sys/shm.h
#include stdio.h
#include semaphore.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#include stdlib.h
#include unistd.h
#include sys/mman.h
#include sys/time.h
#includestring.h
#define SEM_IN_TASK "INX_TASK"
#define SEM_OUT_TASK "OUTX_TASK"
#define BUFSIZE 4096
sem_t *sem_in;
sem_t *sem_out;
main(int argc, char** argv) // map a normal file as shared mem:
{
int fd =-1;
int i= 0;
char *p_map;
double consumetime = 0.0;
struct timeval process_stat , process_end;
fd=open( argv[1],O_CREAT|O_RDWR,00777 );
p_map = (char*)mmap(NULL,BUFSIZE,PROT_READ|PROT_WRITE, MAP_SHARED,fd,0);
sem_in = sem_open(SEM_IN_TASK,O_CREAT,0644,0); //0ok
sem_out=sem_open(SEM_OUT_TASK,O_CREAT,0644,1); //1ok
printf("[sem_in] [%d]\n",sem_in);
printf("[sem_out] [%d]\n",sem_out);
if(sem_in == SEM_FAILED||sem_out == SEM_FAILED)
{
perror("unable to create semaphore-wang");
sem_unlink(SEM_OUT_TASK);
sem_unlink(SEM_IN_TASK);
exit(-1);
}
memset(p_map,0,BUFSIZE);
//gettimeofday(process_stat,NULL);
//while(1)
for(i =0;i50000;i++)
{
memset(p_map,'b',100);
//printf("------------B emit A-----------\n\n\n\n");
sem_post(sem_out);
usleep(200);
sem_wait(sem_in);
//printf("------------A emit B-----------\n\n\n\n");
printf( "B:%s\n",p_map );
}
//gettimeofday(process_end,NULL);
//consumetime = (double)(process_end.tv_sec - process_stat.tv_sec)*1e6 +(double)(process_end.tv_usec - process_stat.tv_usec)/1e6;
//printf("consumetime:[%f]\n",consumetime);
munmap( p_map,BUFSIZE );
}
如果对你有帮助，请给分哦，谢谢！
生产者消费者代码
首先是mutex和semaphore初始化生产者消费者模式源码的代码放到创建线程生产者消费者模式源码的前面。
其实程序生产者消费者模式源码的互斥（mutex）和semaphore都没有问题生产者消费者模式源码，问题在count.
假设运行producer2次生产者消费者模式源码，consumer1次，producer2次，consumer1次
结果会是这样：
producer count1 显示produce0
producer count2 显示produce1
consumer count1 显示consumer1
producer count2 显示produce1
producer count3 显示produce2
consumer count2 显示consume2
所以屏幕输出是不正确的，会忽略掉0和1.
把buffer改成circuler queue, 这样当producer生产到2的时候，consumer仍然是从0开始取出。
#define N 12
int buffer[N];
int front=1;
int rear=1;
produce(item){
buffer[rear-1] = item;
rear = rear%N + 1;//从0存入buffer，当rear值为13时存入buffer0
}
consumer(*item){
*item = buffer[front-1];
front = front%N + 1;
}
