简单消费队列的实现(异步任务处理)

很多情况下要用到生产者-消费者这个模型，比如有很多任务要处理，但是又不能马上得到处理，这个时候就难免要将任务缓存下来慢慢消化。最普通的就是一对一的模式，一个生产者，一个消费者。那么有几个点需要考虑:

1. 生产速度大于消费速度，这个时候就需要队列的支持，需要把任务缓存下来慢慢消化
2. 匀速消化，保证任务执行之间的间隔时间相同，很多情况下我们是有这个要求的，比如有一堆绘制任务，不能无节制的全部交给屏幕绘制，可能会阻塞主线程，这个时候就要给主线程留出交互的空隙。
3. 如果生产速度远远大于消费速度，我们就需要设置队列最大长度，保护我们的程序。
4. 任务丢弃策略，如果任务超出队列，如何丢弃(暂不考虑这个问题)

#include <functional>
#include <memory>
#include <thread>
#include <queue>
#include <condition_variable>

template<typename T>
class ConsumeQueue
{
	typedef std::function<void(T)> ConsumeFunction;
public:
	//consumeRate: 消耗速率(消息个数/1s)
	ConsumeQueue(int consumeRate, int publishQueueMaxSize = 1000);
	~ConsumeQueue() { Stop(); };
	void Publish(T data);
	void Consume(ConsumeFunction consumeFunction);
	void Stop();
	void SetConsumeRate(int rate);
	int  GetConsumeRate();
	int  GetPublishQueueLength();
private:
	void ConsumeThreadFunction(ConsumeFunction consumeFunction);
private:
	std::thread*   m_thread = nullptr;
	//生产者队列
	std::queue<T>  m_publishQueue;
	int            m_consumeRate;
	int            m_publishQueueMaxSize;
	std::condition_variable m_wait;
	std::mutex              m_mut;
	bool           m_isStop = false;
};

template<typename T>
int ConsumeQueue<T>::GetPublishQueueLength()
{
	return m_publishQueue.size();
}

template<typename T>
int ConsumeQueue<T>::GetConsumeRate()
{
	return m_consumeRate;
}

template<typename T>
void ConsumeQueue<T>::SetConsumeRate(int rate)
{
	if (m_consumeRate == rate)
	{
		return;
	}
	m_consumeRate = rate;
}

template<typename T>
void ConsumeQueue<T>::Stop()
{
	{
		std::unique_lock<std::mutex> locker(m_mut);
		m_isStop = true;
		m_wait.notify_all();
	}
	if (m_thread)
	{
		m_thread->join();
		delete m_thread;
		m_thread = nullptr;
	}
}

template<typename T>
void ConsumeQueue<T>::Publish(T data)
{
	if (m_isStop)
	{
		return;
	}
	std::unique_lock<std::mutex> locker(m_mut);
	m_publishQueue.push(data);
	if (m_publishQueue.size() > m_publishQueueMaxSize)
	{
		m_publishQueue.pop();
	}
	m_wait.notify_all();
}

template<typename T>
void ConsumeQueue<T>::Consume(ConsumeFunction consumeFunction)
{
	m_thread = new std::thread([=]() {
		ConsumeThreadFunction(consumeFunction);
	});
}

template<typename T>
ConsumeQueue<T>::ConsumeQueue(int consumeRate, int publishQueueMaxSize)
{
	m_consumeRate = consumeRate;
	m_publishQueueMaxSize = publishQueueMaxSize;
}

template<typename T>
void ConsumeQueue<T>::ConsumeThreadFunction(ConsumeFunction consumeFunction)
{
	while (!m_isStop)
	{
		std::unique_lock<std::mutex> locker(m_mut);
		if (m_publishQueue.empty())
		{
			m_wait.wait(locker);
		}
		if (m_isStop)
		{
			return;
		}
		std::queue<T> consumeQueue;
		consumeQueue.swap(m_publishQueue);
		locker.unlock();
		while (!consumeQueue.empty() && !m_isStop)
		{
			consumeFunction(consumeQueue.front());
			consumeQueue.pop();
			std::this_thread::sleep_for(std::chrono::milliseconds(1000 / m_consumeRate));
		}
	}
}

Publish是生产接口，将任务加入到队列中，可以是函数对象，也可以是string，int等等

Consume接受一个lambda或者一个函数，这个是消费接口，也就是会将数据在这里吐出，可以在这个函数中对数据处理，但是需要注意，Consume接口是在另外一个线程中执行的，注意目的，ui绘制的操作不能放在这里。

构造函数中的两个参数: consumeRate是指1秒钟要消费任务的个数，publishQueueMaxSize是指缓存队列的最大长度，超出会将新消息加入，并将最早的消息丢弃掉。