Linux组件封装(四) Buffer的封装

这里，我们需要将缓冲区封装起来，然后让缓冲区与线程想连接，所以我们需要一个相应的接口。

在Buffer中，我们需要想对应的一把锁与两个条件变量。

当满足队列为空时，消费者等待，反之，生产者等待。

Buffer的声明如下:

#ifndef BUFFER_H
#define BUFFER_H

#include "NonCopyable.h"
#include "MutexLock.h"
#include "Condition.h"
#include <queue>


class Buffer : private NonCopyable
{
public:

    Buffer(size_t queueSize);

    void push(int val);
    int pop();

    bool empty() const;
    size_t size() const;

private:

    mutable MutexLock _mutex;
    Condition _full;
    Condition _empty;
    size_t _queueSize;
    std::queue<int> _queue;
};


#endif  /*BUFFER_H*/

在这里，我们引用MutexLockGuard来解决忘记解锁的问题，当我们定义一个该类的对象时，·自动上锁，
当该对象销毁时，自动解锁。

当然，有一种使用方式是错误的，例如:

size_t Buffer::size() const
{
    MutexLockGuard(mutex_);
    return queue_.size();
}

这段代码的加锁周期仅在那一行有效，所以该种方法是错误的，所以，我们定义一个宏(在Mutex.h文件中可找到):

#define MutexLockGuard(m) "Error"

这样当错误使用时，会导致编译错误，使我们早些发现问题。

cpp实现代码如下:

#include "Buffer.h"
#include "Thread.h"
using namespace std;

Buffer::Buffer(size_t queueSize)
    :_full(_mutex),
     _empty(_mutex),
     _queueSize(queueSize)
{

}

bool Buffer::empty() const
{
    MutexLockGuard lock(_mutex);
    return _queue.empty();
}

size_t Buffer::size() const
{
    MutexLockGuard lock(_mutex);
    return _queue.size();
}

void Buffer::push(int val)
{
    {
        MutexLockGuard lock(_mutex);
        while(_queue.size() > _queueSize)
            _empty.wait();
        _queue.push(val);
    }
    _full.notify();
}

int Buffer::pop()
{
    int tmp = 0;
    {
        MutexLockGuard lock(_mutex);
        while(_queue.empty())
            _full.wait();
        tmp = _queue.front();
        _queue.pop();
    }
    _empty.notify();
    return tmp;
}