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

生产和消费思路：

生产时先扫描一遍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;
}