Muduo库源码分析（6）：有界缓冲区，无界缓冲区

缓冲区的实现

类似于生产者消费者模型，往缓冲区添加任务相当于生产者，从缓冲区提取任务相当于消费者，Muduo库使用条件变量加互斥锁实现的有界和无界缓冲区

简易的条件变量加互斥锁实现的生产者消费者模型（无界）实现：

http://blog.csdn.net/zjf280441589/article/details/43883113

有界缓冲区

class BoundedBlockingQueue : noncopyable
{
public:
explicit BoundedBlockingQueue(int maxSize)
: mutex_(),
notEmpty_(mutex_),
notFull_(mutex_),
queue_(maxSize)
{
}

void put(const T& x)
{
MutexLockGuard lock(mutex_);
while (queue_.full())
{
notFull_.wait();
}
assert(!queue_.full());
queue_.push_back(x);
notEmpty_.notify();
}

T take()
{
MutexLockGuard lock(mutex_);
while (queue_.empty())
{
notEmpty_.wait();
}
assert(!queue_.empty());
T front(queue_.front());
queue_.pop_front();
notFull_.notify();
return front;
}

bool empty() const
{
MutexLockGuard lock(mutex_);
return queue_.empty();
}

bool full() const
{
MutexLockGuard lock(mutex_);
return queue_.full();
}

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

size_t capacity() const
{
MutexLockGuard lock(mutex_);
return queue_.capacity();
}

private:
mutable MutexLock     mutex_;// 互斥量
Condition             notEmpty_;// 条件变量表明可消费的数量
Condition             notFull_;// 条件变量表明可生产的数量
circular_buffer<T>    queue_;// 环形缓冲区
};

无界缓冲区

class BlockingQueue : noncopyable
{
public:
BlockingQueue()
: mutex_(),
notEmpty_(mutex_),
queue_()
{
}

void put(const T& x)
{
MutexLockGuard lock(mutex_);
queue_.push_back(x);
notEmpty_.notify();
}

void put(T&& x)
{
MutexLockGuard lock(mutex_);
queue_.push_back(std::move(x));
notEmpty_.notify();
}

T take()
{
MutexLockGuard lock(mutex_);
while (queue_.empty())
{
notEmpty_.wait();
}
assert(!queue_.empty());
T front(std::move(queue_.front()));
queue_.pop_front();
return front;
}

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

private:
mutable MutexLock mutex_;// 互斥量
Condition         notEmpty_;// 条件变量表明可消费的数量
std::deque<T>     queue_;// 队列
};