Windows下一个并发阻塞队列（BlockingQueue）

Windows下一个带有大小限制的并发阻塞队列，实现的比较简单。

#ifndef BLOCKINGQUEUE_H_
#define BLOCKINGQUEUE_H_

#include <queue>
#include <windows.h>
using namespace std;

template <typename T>
class BoundedBlockingQueue 
{ 
public: 
    BoundedBlockingQueue(int size) : maxSize(size) 
    {
        _lock = CreateMutex(NULL,false,NULL);
        _rsem = CreateSemaphore(NULL,0,size,NULL);
        _wsem = CreateSemaphore(NULL,size,size,NULL);
    } 
    ~BoundedBlockingQueue() 
    { 
        CloseHandle(_lock);
        CloseHandle(_rsem);
        CloseHandle(_wsem);
    } 
    void push(const T& data);
    T pop();
    bool empty()
    {
        WaitForSingleObject(_lock,INFINITE);
        bool is_empty = _array.empty();
        ReleaseMutex(_lock);
        return is_empty;
    }
private: 
    deque<T> _array;
    int maxSize;
    HANDLE _lock;
    HANDLE _rsem, _wsem;
};

template <typename T>
void BoundedBlockingQueue <T>::push(const T& value ) 
{ 
    WaitForSingleObject(_wsem,INFINITE);
    WaitForSingleObject(_lock,INFINITE);
    _array.push_back(value);
    ReleaseMutex(_lock);
    ReleaseSemaphore(_rsem,1,NULL);
}

template <typename T>
T BoundedBlockingQueue<T>::pop() 
{ 
    WaitForSingleObject(_rsem,INFINITE);
    WaitForSingleObject(_lock,INFINITE);
    T _temp = _array.front();
    _array.pop_front();
    ReleaseMutex(_lock);
    ReleaseSemaphore(_wsem,1,NULL);
    return _temp;
}

#endif

主函数调用测试：一个生产者、两个消费者使用这个队列进行测试。

#include "BlockingQueue.h"
#include <windows.h>
#include <iostream>
using namespace std;

bool is_over = false;

DWORD WINAPI produce(LPVOID lppara)
{
    BoundedBlockingQueue<int> *queue = (BoundedBlockingQueue<int> *)lppara;

    while(1)
    {
        for(int i=1; i<=50; ++i)
        {
            queue->push(i);
            cout<<GetCurrentThreadId()<<" put a data: "<<i<<endl;
            Sleep(10); //producer is fast
        }
        is_over = true;
        break;
    }
    return NULL;
}

DWORD WINAPI consume(LPVOID lppara)
{
    BoundedBlockingQueue<int> *queue = (BoundedBlockingQueue<int> *)lppara;

    while(1)
    {
        int d = queue->pop();
        cout<<GetCurrentThreadId()<<" get data: "<<d<<endl;
        //double check
        if(is_over && queue->empty())
        {
            cout<<"OVER!"<<endl;
            break;
        }
        Sleep(10); //consumer is slow
    }
    return NULL;
}

int main()
{
    DWORD write_data;
    DWORD read_data;
    DWORD read_data1;

    BoundedBlockingQueue<int> queue(20);

    //一个生产者、两个消费者
    if(CreateThread(NULL,0,produce,&queue,0,&write_data)==NULL)
        return -1;
    if(CreateThread(NULL,0,consume,&queue,0,&read_data)==NULL)
        return -1;
    if(CreateThread(NULL,0,consume,&queue,0,&read_data1)==NULL)
        return -1;

    char ch;
    while(1)
    {
        ch = getchar(); //press "e" to exit
        if(ch == 'e') break;
    }

    printf("Program ends successfully\n");

    return 0;
}