c++多线程生产者与消费者问题代码

1.目录结构

2.代码

BufferPool.h

#ifndef BUFFERPOOL
#define BUFFERPOOL
#include<windows.h>
#include<vector>
#include<iostream>
#include<string>
#define SIZE_OF_BUFFER 4
using namespace std;
//控制参数类
class BufferPool
{
public:static BufferPool * GetInstance();void Produce();void Consume();void Product_Sum();//多线程互斥信号量HANDLE mutex;HANDLE mutex2;//多线程同步信号量//空缓冲区HANDLE m_hSemaphoreBufferEmpty;//非空缓冲区HANDLE m_hSemaphoreBufferFull;unsigned int produce_sum;            //the total produce numberunsigned int consume_sum;            //the total consume numberprivate:unsigned short in;                   //the mark of position entering the space unsigned short out;                  //the mark of position leaving the spaceunsigned int Product_ID;unsigned int Consume_ID;static BufferPool *m_Instance;int buffer[SIZE_OF_BUFFER];          //缓冲池BufferPool(){int i = 0;in = out = 0;produce_sum = consume_sum = 0;Product_ID = Consume_ID = 0;for(;i < SIZE_OF_BUFFER; i++)buffer[i] = 0;};};
#endif

Consume.h

#ifndef CONSUME
#define CONSUME
#include "BufferPool.h"
#include<windows.h>
#include<vector>
#include<iostream>
#include<string>
class Consume
{
public:
Consume(){};
~Consume(){};
//消费产品
DWORD WINAPI ConsumeProduct(LPVOID lpParam);
};
#endif

Product.h

#ifndef PRODUCT
#define PRODUCT
#include "BufferPool.h"
#include<windows.h>
#include<vector>
#include<iostream>
#include<string>
class Product
{
public:
Product(){};
~Product(){};
//消费产品
DWORD WINAPI producer(LPVOID lpParam);
};
#endif

BufferPool.cpp

#include "BufferPool.h"//---------------------------------------------------------------------------//---------------------------------------------------------------------------
//unsigned short in, out;
//in = out = 0;
//获取单例实例
BufferPool * BufferPool::m_Instance = new BufferPool();BufferPool * BufferPool::GetInstance()
{
if(NULL == m_Instance)
{
m_Instance = new BufferPool();
}
return  m_Instance;
}void BufferPool::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 BufferPool::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();
}void BufferPool::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("   %d\n", sum);
}

consume.cpp

#include "Consume.h"
//---------------------------------------------------------------------------DWORD WINAPI Consume::ConsumeProduct(LPVOID lpParam)
{while (true){//等待非空的缓冲区出现，消费者进行消费，直到事件值为0WaitForSingleObject(BufferPool::GetInstance()->m_hSemaphoreBufferFull, INFINITE);WaitForSingleObject(BufferPool::GetInstance()->mutex2,INFINITE);                //the mutex P operationBufferPool::GetInstance()->Consume();Sleep(1000);ReleaseMutex(BufferPool::GetInstance()->mutex2);                                //resource semaphore P operationReleaseSemaphore(BufferPool::GetInstance()->m_hSemaphoreBufferEmpty,1,NULL);            //the mutex P operation}return 0;
}

Main_prg.cpp

#include<stdlib.h>
#include<windows.h>
#include "BufferPool.h"
#include "Product.h"
#include "Consume.h"typedef DWORD (WINAPI *pTheadFunc)(LPVOID lpParam);const unsigned short p_count=5;        //the number of produce one time
const unsigned short c_count=5;        //the number of consumer one time
const unsigned short s_count=p_count+c_count;  //the sum number of threads
bool control = true;
HANDLE threads[s_count];               //the handle of every thread
DWORD Producer_threadID[p_count];            //the mark of producer thread
DWORD Consumer_threadID[c_count];            //the mark of consumer threadvoid Create_P_Threads();
void Create_C_Threads();void Create_P_Threads()                                  //create producer thread
{for(int i=0;i<p_count;i++){DWORD (WINAPI Product::*pProductPoint)(LPVOID lpParam) = &Product::producer;int* ptemp= (int*)&pProductPoint;DWORD (WINAPI *pProductThread)(LPVOID lpParam) = *(pTheadFunc*)ptemp;//生产者线程threads[i]=CreateThread(NULL,0,pProductThread,NULL,0,&Producer_threadID[i]);if(threads[i]==NULL)control=false;}
}void Create_C_Threads()
{for(int i=p_count;i<s_count;i++){DWORD (WINAPI Consume::*pConsumePoint)(LPVOID lpParam) = &Consume::ConsumeProduct;int* ptemp= (int*)&pConsumePoint;DWORD (WINAPI *pConsumeThread)(LPVOID lpParam) = *(pTheadFunc*)ptemp;//消费者线程threads[i]=CreateThread(NULL,0,pConsumeThread,NULL,0,&Consumer_threadID[i-p_count]);if(threads[i]==NULL)control=false;}
}void info()
{std::cout<<"\n"<<std::endl;std::cout<<"produce/consume    used_total  buffer_state(from 0 to 9)"<<std::endl;
}int main()
{info();BufferPool::GetInstance()->mutex=CreateMutex(NULL,FALSE,NULL);BufferPool::GetInstance()->mutex2=CreateMutex(NULL,FALSE,NULL);BufferPool::GetInstance()->m_hSemaphoreBufferFull=CreateSemaphore(NULL,0,SIZE_OF_BUFFER,NULL);BufferPool::GetInstance()->m_hSemaphoreBufferEmpty=CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);Create_C_Threads();Create_P_Threads();while(control){if(getchar()){std::cout<<std::endl;std::cout<<"the total produce product number is "<<BufferPool::GetInstance()->produce_sum<<std::endl;std::cout<<"the total consume product number is "<<BufferPool::GetInstance()->consume_sum<<std::endl;break;}}return 0;
}

Product.cpp

#include "Product.h"
//---------------------------------------------------------------------------
DWORD WINAPI  Product::producer(LPVOID lpParam)
{while (true){//等待非空的缓冲区出现，消费者进行消费，直到信号量值为0WaitForSingleObject(BufferPool::GetInstance()->m_hSemaphoreBufferEmpty, INFINITE);WaitForSingleObject(BufferPool::GetInstance()->mutex,INFINITE);                //the mutex P operationBufferPool::GetInstance()->Produce();Sleep(1000);ReleaseMutex(BufferPool::GetInstance()->mutex);                                //resource semaphore P operationReleaseSemaphore(BufferPool::GetInstance()->m_hSemaphoreBufferFull,1,NULL);            //the mutex P operation}return 0;
}

运行效果

c++多线程生产者与消费者问题代码相关推荐

Java多线程-生产者与消费者
Java多线程生产者与消费者,准确说应该是"生产者-消费者-仓储"模型,使用了仓储,使得生产者消费者模型就显得更有说服力. 对于此模型,应该明确一下几点: 1.生产者仅仅在仓储未满 ...
java多线程生产者与消费者问题_Java多线程详解之四:生产者消费者问题
一.问题描述生产者消费者问题(Producer-Consumer problem),也称有限缓冲区问题(Bounded-buffer promblem),是一个多线程同步问题的经典案例.对于一个固定 ...
java多线程生产者与消费者案例_多线程操作实例——生产者与消费者
面对多线程学习生产者与消费者是最基本的实例对于java后端开发的人员必须要掌握,还有考研考试计算机操作系统的同鞋. 下面是三个实例对于生产者与消费者的的例子,层层递进,逐步解决问题. 问题:生产者- ...
Java基础进阶多线程-生产者和消费者模式
1.什么是"生产者和消费者模式"? 生产线程负责生产,消费线程负责消费生产线程和消费线程要达到均衡这是一种特殊的业务需求,在这种特殊的情况下需要使用wait方法和notify方 ...
java多线程生产者与消费者问题_java多线程实现生产者与消费者问题
生产者与消费者多线程实现,首先的问题就是同步,就是关于临界资源的访问我们首先来定义一个临界资源类,这里设为Q class Q { int z=4; } 这个int型的z就是我假设的临界资源的个数然 ...
操作系统生产者与消费者问题代码实现
问题分析: ①假设系统中有一个比较大的缓冲池,生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中,而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品.缓冲池被占用时,任何进程都不能访问. ② ...
C++多线程-生产者与消费者模型
生产者-消费者是很有意思的一种算法.它的存在主要是两个目的,第一就是满足生产者对资源的不断创造:第二就是满足消费者对资源的不断索取.当然,因为空间是有限的,所以资源既不能无限存储,也不能无限索取. 生 ...
多线程——生产者与消费者（多）1.5新锁，问题解决
package 多线程;import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; imp ...
Java 多线程-生产者、消费者
一.整体代码 ThreadDemo.java public class ThreadDemo { public static void main(String[] args) { Godown god ...

c++多线程生产者与消费者问题代码

c++多线程生产者与消费者问题代码相关推荐

最新文章

热门文章