生产者消费者模式

#include <string>
#include <queue>
#include <iostream>
#include <memory>
#include <Windows.h>
using namespace std;

//缓冲区类
class CBuffer
{
public:
CBuffer(void) { InitializeCriticalSection(&cs); }
~CBuffer(void) { DeleteCriticalSection(&cs); }

static CBuffer* getBuffer()
{
if (!buffer)
{
buffer = new CBuffer();
}
return buffer;
}

int getSize() {
EnterCriticalSection(&cs);
int nSize = buffer_list.size();
LeaveCriticalSection(&cs);
return nSize;
}
bool isEmpty() {
EnterCriticalSection(&cs);
bool is_empty = buffer_list.empty();
LeaveCriticalSection(&cs);
return is_empty; 
}
bool isFull() {
EnterCriticalSection(&cs);
bool is_full = buffer_list.size() == BUFFER_SIZE;
LeaveCriticalSection(&cs);
return is_full;
}

bool push(string& str) 
{
if (!isFull())
{
EnterCriticalSection(&cs);
buffer_list.push(str);
LeaveCriticalSection(&cs);
return true;
}
return false;
}
bool popup(string& str)
{
if (!isEmpty())
{
EnterCriticalSection(&cs);
str = buffer_list.front();
buffer_list.pop();
LeaveCriticalSection(&cs);
return true;
}
return false;
}

private:
queue<string> buffer_list;
CRITICAL_SECTIONcs;
static CBuffer*buffer;
static int BUFFER_SIZE;
};
int CBuffer::BUFFER_SIZE = 1000;
CBuffer* CBuffer::buffer = NULL;

BOOL bThreadStart = TRUE;
shared_ptr<CBuffer> pBuffer(CBuffer::getBuffer());

//生产者类
class Producer
{
public:
Producer(void) {}
~Producer(void) {}

bool produce(string& prostr)
{
return pBuffer->push(prostr);
}
};

//消费者类
class Consumer
{
public:
Consumer(void) {}
~Consumer(void) {}

bool consume(string& constr)
{
return pBuffer->popup(constr);
}
};

DWORD WINAPI ThreadProduce(LPVOID pM)
{
string str = "123";
Producer producer;
while (bThreadStart)
{
if (producer.produce(str))
{
cout<<"produce: "<<str<<endl;
}
else
{
Sleep(10);
}
}
return 0;
}

DWORD WINAPI ThreadConsume(LPVOID pM)
{
string str;
Consumer consumer;
while (bThreadStart)
{
if (consumer.consume(str))
{
cout<<"consume: "<<str<<endl;
} 
else
{
Sleep(100);
}
}
return 0;
}

int main()
{
HANDLE hProducer = CreateThread(NULL, 0, ThreadProduce, NULL, 0, NULL);
HANDLE hConsumer = CreateThread(NULL, 0, ThreadConsume, NULL, 0, NULL);

getchar();
bThreadStart = FALSE;
if (WAIT_TIMEOUT == WaitForSingleObject(hProducer, 3000))
TerminateThread(hProducer, 0);
CloseHandle(hProducer);

if (WAIT_TIMEOUT == WaitForSingleObject(hConsumer, 3000))
TerminateThread(hConsumer, 0);
CloseHandle(hConsumer);

return 0;
}