muduo源码分析：无界队列和有界队列（消费者-生产者）

最新推荐文章于 2025-03-10 16:10:13 发布

le119126

最新推荐文章于 2025-03-10 16:10:13 发布

阅读量1.4k

点赞数

分类专栏： muduo c++ 文章标签： muduo 队列

本文链接：https://blog.youkuaiyun.com/le119126/article/details/50238449

版权

c++ 同时被 2 个专栏收录

104 篇文章

订阅专栏

muduo

10 篇文章

订阅专栏

本文分析了muduo库中的无界队列和有界队列。无界队列允许不断生产，使用deque存储产品，生产时立即通知消费者，只需一个mutex和notEmpty条件变量。有界队列则参照c++教程网和《Linux多线程服务器端编程》进行实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

muduo库的队列很简单：

无界队列

put --生产

take--消费

size--返回现在的产品数

产品存放在deque里面

无界队列可以一直生产put，所以不用等待队列中有位置才生产，每生产一个产品就notify，只要通知一个消费者，不需要通知所有人

只有消费take时要判断有无产品，所以只需要一个mutex锁，一个条件变量notEmpty，消费者用来等待notEmpty有产品可以消费

#ifndef MUDUO_BASE_BLOCKINGQUEUE_H
#define MUDUO_BASE_BLOCKINGQUEUE_H

#include <muduo/base/Condition.h>
#include <muduo/base/Mutex.h>

#include <boost/noncopyable.hpp>
#include <deque>
#include <assert.h>

namespace muduo
{
template<typename T>
class BlockingQueue : boost::noncopyable
{
  public:
	explicit BlockingQueue()
		  :mutex_(),
		   notEmptyCond_(mutex_),
		   queue_()
	{}
	void put(const T& t)
	{
		{
			MutexLockGuard lock(mutex_);
			queue_.push_back(t);
		}
		notEmptyCond_.notify();//不需要notifyAll通知所有的，如果有阻塞，代表原先为空，现在只生产了一个，也只要一个消费来就足够了
	}
	T take()
	{
		MutexLockGuard lock(mutex_);
		while(queue_.empty())
		  notEmptyCond_.wait();
		assert(!queue_.empty());
		T front=queue_.front();
		queue_.pop_front();
		return front;
	}
	size_t size() const
	{
		MutexLockGuard lock(mutex_);
		return queue_.size();
	}

  private:
	mutable MutexLock mutex_;
	Condition notEmptyCond_;
	std::deque<T> queue_;
};

}

#endif

有界队列

有界队列用boost::circular_buffer<T> queue_实现

因为有界，所以生产的时候要等待有位置才能生产--用条件变量notFull

消费时用notEmpty条件变量等待有产品可以消费。

生产者和消费者处理的资源都是同一个queue_，所以是两个条件变量（一个等待非空，一个等待非满），但是只要一把mutex_锁，两个条件变量共用一把锁

// Use of this source code is governed by a BSD-style license
// that can be found in the License file.
//
// Author: Shuo Chen (chenshuo at chenshuo dot com)

#ifndef MUDUO_BASE_BOUNDEDBLOCKINGQUEUE_H
#define MUDUO_BASE_BOUNDEDBLOCKINGQUEUE_H

#include <muduo/base/Condition.h>
#include <muduo/base/Mutex.h>

#include <boost/circular_buffer.hpp>
#include <boost/noncopyable.hpp>
#include <assert.h>

namespace muduo
{

template<typename T>
class BoundedBlockingQueue : boost::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(); // TODO: move outside of lock
  }

  T take()
  {
    MutexLockGuard lock(mutex_);
    while (queue_.empty())
    {
      notEmpty_.wait();
    }
    assert(!queue_.empty());
    T front(queue_.front());
    queue_.pop_front();
    notFull_.notify(); // TODO: move outside of lock
    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_;
  boost::circular_buffer<T>  queue_;
};

}

#endif  // MUDUO_BASE_BOUNDEDBLOCKINGQUEUE_H

如果不用boost的circular_buffer。可以用数组实现，putIndex=0 将要生产的位置；takeInex=0 将要读的位置，isFull=false 产品是否满了， isEmpty=ture 产品空了；

put( ) {

lock( );

produce;//putIndex=0，刚开始直接生产没问题，但是把wait写后面在（2）的位置就错了---------------（1）

notify(notEmpty);

putIIndex++;

putIndex%=maxSize;

isEmpty=fase；

if(putIndex==takeIndex) //没有位置可以生产了

{

isFull=true;

wait(notFull); //不可以，错了---------------------------------------（2）