c++多线程实现生产者消费者

最新推荐文章于 2024-09-30 06:00:00 发布

tingyuanss

最新推荐文章于 2024-09-30 06:00:00 发布

阅读量1w

点赞数 2

分类专栏： c++编程

本文链接：https://blog.csdn.net/tingyuanss/article/details/8832214

版权

c++编程专栏收录该内容

23 篇文章 0 订阅

订阅专栏

生产和消费思路：

生产时先扫描一遍buffer找到第一个为0(即没有产品)的位置，生产一个产品，并把产品编号(从1到10循环)存在这里。

消费时先扫描一遍buffer找到第一个不为1(即有产品)的位置，消费一个产品，并使此时位置存的数0(即没有产品)

结果示意图：

Producer/consume：表示生产者或者消费者生产或消费的产品的位置以及产品号。

如：Produce buffer[0]=1， buffer[0]表示缓冲区第一个位置，1是产品编号不是数目，每个缓冲区数组单元代表一个产品，存的是产品编号（在1-10内）。

remain_total：表示缓冲区现在的产品数量。

Buffer_state：打印buffer共10个数，里面存的是产品编号（1-10），0代表没有产品。

为了便于观察，我在void produce（）和void consume（）函数里加了一句Sleep(1000),如果要加快程序可以把1000改小。

我用的是英文注释，p_count表示生产者进程数目，我设置为s_count为消费者进程，我设置为6，可改变他们的值从而改变不同进程的数目。

按enter键可以终止程序，会出现一段信息：

总共生产了36个，消耗了30个。

/*
* main.cpp
*
* Created on: 2013-4-15
* Author: 许亚文

#include<windows.h>
#include<iostream>

const unsigned short SIZE_OF_BUFFER=10; //the length of buffer
unsigned short buffer[SIZE_OF_BUFFER]={0}; //create space for buffer
unsigned short in=0;                   //the mark of position entering the space
unsigned short out=0;                  //the mark of position leaving the space
unsigned short Product_ID=0;           //the ID of product,from 1 to 10,not for count
unsigned short Consume_ID=0;           //the ID of consume product_ID in the buffer
unsigned int produce_sum=0;            //the total produce number
unsigned int consume_sum=0;            //the total consume number
HANDLE mutex;                          //the mutex between threads
HANDLE Full_Semaphore;                 //the resource semaphore: buffer is full
HANDLE Empty_Semaphore;                //the resource semaphore: buffer is empty
const unsigned short p_count=20;        //the number of produce one time
const unsigned short c_count=6;        //the number of consumer one time
const unsigned short s_count=p_count+c_count; //the sum number of threads
HANDLE threads[s_count];               //the handle of every thread
DWORD Producer_ID[p_count];            //the mark of producer thread
DWORD Consumer_ID[c_count];            //the mark of consumer thread
unsigned short control=1;              //control the program run or stop

DWORD WINAPI producer(LPVOID);         //the producer thread
DWORD WINAPI consumer(LPVOID);         //the consumer thread
void produce();
void consume();
void Create_P_Threads();               //create producer thread
void Create_C_Threads();               //create consumer thread
void Product_Sum();                    //print the total of remain product number and print the buffer
void info();                           //info

void Product_Sum()
{
int i,sum=0;
for(i=0;i<SIZE_OF_BUFFER;i++)
{
  if(buffer[i]!=0)
   sum++;
}
std::cout<<" "<<sum<<"         ";
for(i=0;i<SIZE_OF_BUFFER;i++)
{
  std::cout<<buffer[i]<<" ";
}
printf("\n");
}

void produce()
{
int i;
std::cout<<"produce";
if(Product_ID>=10)
  Product_ID=0;
Product_ID++;
produce_sum++;
buffer[in]=Product_ID;
printf(" buffer[%d]=%d    ",in,Product_ID);
in=(in+1)%SIZE_OF_BUFFER;
    Product_Sum();
}

void consume()
{
int i;
std::cout<<"consume";
consume_sum++;
Consume_ID=buffer[out];
printf(" buffer[%d]=%d ",out,Consume_ID);
buffer[out]=0;
out=(out+1)%SIZE_OF_BUFFER;
Product_Sum();
}

DWORD WINAPI producer(LPVOID)                               //producer thread
{
while(control)
{
  WaitForSingleObject(Full_Semaphore,INFINITE);       //resource semaphore P operation
        WaitForSingleObject(mutex,INFINITE);                //the mutex P operation
  produce();
  Sleep(1000);
  ReleaseMutex(mutex);                                //resource semaphore P operation
  ReleaseSemaphore(Empty_Semaphore,1,NULL);            //the mutex P operation
}
return 0;
}

DWORD WINAPI consumer(LPVOID)                              //consumer thread
{
while(control)
{
  WaitForSingleObject(Empty_Semaphore,INFINITE);
  WaitForSingleObject(mutex,INFINITE);
  consume();
  Sleep(1000);
  ReleaseMutex(mutex);
  ReleaseSemaphore(Full_Semaphore,1,NULL);
}
return 0;
}

void Create_P_Threads()                                  //create producer thread
{
for(int i=0;i<p_count;i++)
{
  threads[i]=CreateThread(NULL,0,producer,NULL,0,&Producer_ID[i]);
  if(threads[i]==NULL)
   control=0;
}
}

void Create_C_Threads()
{
for(int i=p_count;i<s_count;i++)
{
  threads[i]=CreateThread(NULL,0,consumer,NULL,0,&Consumer_ID[i-p_count]);
  if(threads[i]==NULL)
   control=0;
}
}

void info()
{
std::cout<<"\n"<<std::endl;
std::cout<<"**********I did refer to the program on the web."<<std::endl;
    std::cout<<"*******and I simplify some things and make it more powful!"<<std::endl;
    std::cout<<"**But it is really a word a word knocked out by me based on understanding\n"<<std::endl;
std::cout<<"produce/consume    remain_total buffer_state(from 0 to 9)"<<std::endl;
}

int main()
{
info();
mutex=CreateMutex(NULL,FALSE,NULL);
Full_Semaphore=CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);
Empty_Semaphore=CreateSemaphore(NULL,0,SIZE_OF_BUFFER,NULL);
Create_P_Threads();
Create_C_Threads();
while(control)
{
  if(getchar())
  {
   std::cout<<std::endl;
   std::cout<<"the total produce product number is "<<produce_sum<<std::endl;
   std::cout<<"the total consume product number is "<<consume_sum<<std::endl;
   control=0;
  }
}
return 0;
}