C++阻塞队列

//阻塞队列，队列可以存无限制个数的元素
template<typename T>
class BlockingQueue {
public:
    BlockingQueue() : _mutex(), _condvar(), _queue() { }

    void Put(const T &task) {
        {
            std::lock_guard<std::mutex> lock(_mutex);
            _queue.push_back(task);
        }
        _condvar.notify_all();
    }

    T Take() {
        std::unique_lock<std::mutex> lock(_mutex);
        _condvar.wait(lock, [this] { return !_queue.empty(); });
        assert (!_queue.empty());
        T front(_queue.front());
        _queue.pop_front();
        return front;
    }

    size_t Size() const {
        std::lock_guard<std::mutex> lock(_mutex);
        return _queue.size();
    }

private:
    BlockingQueue(const BlockingQueue &rhs);

    BlockingQueue &operator=(const BlockingQueue &rhs);

private:
    mutable std::mutex _mutex;
    std::condition_variable _condvar;
    std::list<T> _queue;
};

//20个为满队列，BlockingQueue<T*> a(20);

template<class T>
class BlockingQueue {
public:
    BlockingQueue(int count):_nready(0) {
        this->count = count;

        pthread_mutex_init(&_not_full_mutex, NULL);
        pthread_mutex_init(&_not_empty_mutex, NULL);
        pthread_cond_init(&_not_full_cond, NULL);
        pthread_cond_init(&_not_empty_cond, NULL);
    }

    int Put(T &d) {

        pthread_mutex_lock(&_not_full_mutex);
        while (_nready >= count)
            pthread_cond_wait(&_not_full_cond, &_not_full_mutex);

        _queue.push_back(d);
        _nready++;
        pthread_cond_signal(&_not_empty_cond);
        pthread_mutex_unlock(&_not_full_mutex);

        return 0;
    }

    int Take(T &d) {
        pthread_mutex_lock(&_not_empty_mutex);
        while (_nready <= 0)
            pthread_cond_wait(&_not_empty_cond, &_not_empty_mutex);

        d = _queue.front();
        _queue.pop_front();
        _nready--;
        pthread_cond_signal(&_not_full_cond);
        pthread_mutex_unlock(&_not_empty_mutex);

        return 0;

    }

private:
    int _nready;
    int count;
    pthread_mutex_t _not_full_mutex;
    pthread_mutex_t _not_empty_mutex;
    pthread_cond_t _not_full_cond;
    pthread_cond_t _not_empty_cond;

    deque<T> _queue;
};

感谢：http://blog.csdn.net/sunxiaolei/article/details/8799314

转载于:https://my.oschina.net/u/563828/blog/877619