再谈多线程模型之生产者消费者（多生产者和单一消费者 ）（c++11实现）

0.关于

为缩短篇幅，本系列记录如下：
再谈多线程模型之生产者消费者（基础概念）（c++11实现）
再谈多线程模型之生产者消费者（单一生产者和单一消费者）（c++11实现）
再谈多线程模型之生产者消费者（单一生产者和多消费者）（c++11实现）
再谈多线程模型之生产者消费者（多生产者和单一消费者 ）（c++11实现）【本文】
再谈多线程模型之生产者消费者（多生产者和多消费者 ）（c++11实现）
再谈多线程模型之生产者消费者（总结）（c++11实现）

本文涉及到的代码演示环境： VS2017

欢迎留言指正

1.多生产者&单一消费者

• 1.1 与 单一生产者和多消费者模型类似， 因为存在多个生产者，需要考虑生产者之间的互斥访问; 消费者只有一个，因此不存在消费者之间的互斥与竞争。

• 1.2 多个生产者， 可能同时放入商品，类比吃水果，父母同时向果盘放入水果，只有子女中的一个吃水果的情况。

• 1.3 具体点

  情况	处理
  生产者速率 > 消费者速率	消费者只有一个，因此，不存在消费者之间的竞争。生产者存在多个，多个生产者之间生产好数据就需要按照竞争将数据放入缓冲区，谁先拿到锁，谁就先放入。最开始，生产者有多个，只能通过竞争生产。但是由于生产效率大于消费速率， 所以定然会出现商品数量 > 消费者数量。当商品总量达到总数，则需要暂停生产，等待消费者消费
  生产者速率 < 消费者速率	最开始，剩余放入总数 > 生产者总数，可以同时放入，随着时间的推移，可能会出现： 剩余放入空间 > 生产者总数 和 剩余放入空间 < 生产者总数。 当出现 剩余空间 < 生产者总数 时，已经不满足同时放入，此时就需要锁。来保证

• 1.4 结构体模型

template<typename T>
struct repo_
{
	// 用作互斥访问缓冲区
	std::mutex				_mtx_queue;

	// 缓冲区最大size
	unsigned int			_count_max_queue_10 = 10;

	// 缓冲区
	std::queue<T>			_queue;

	// 缓冲区没有满，通知生产者继续生产
	std::condition_variable _cv_queue_not_full;

	// 缓冲区不为空，通知消费者继续消费
	std::condition_variable _cv_queue_not_empty;

	// 用于生产者之间的竞争
	std::mutex				_mtx_pro;
	// 计算当前已经生产了多少数据了
	unsigned int			_cnt_cur_pro = 0;

	repo_(const unsigned int count_max_queue = 10) :_count_max_queue_10(count_max_queue)
		, _cnt_cur_con(0)

	{
		;
	}

	repo_(const repo_&instance) = delete;
	repo_& operator = (const repo_& instance) = delete;
	repo_(const repo_&&instance) = delete;
	repo_& operator = (const repo_&& instance) = delete;

};

对比单一生产者和单一消费者 可知，仅仅增加了下面的代码

// 用于生产者之间的竞争
std::mutex				_mtx_pro;
// 计算当前已经生产了多少数据了
unsigned int			_cnt_cur_pro = 0;

• 1.5 生产者线程变化如下

template< typename T >
void thread_pro(const int thread_index, const int count_max_produce, repo<T>* param_repo)
{
	if (nullptr == param_repo || NULL == param_repo)
		return;
	

	while (true)
	{
		bool is_running = true;

		{
			// 用于生产者之间竞争
			std::unique_lock<std::mutex> lock(param_repo->_mtx_pro);

			// 缓冲区没有满，继续生产
			if (param_repo->_cnt_cur_pro < cnt_total_10)
			{
				thread_produce_item<T>(thread_index, *param_repo, param_repo->_cnt_cur_pro);
				++param_repo->_cnt_cur_pro;
			}
			else
				is_running = false;
		}

		std::this_thread::sleep_for(std::chrono::microseconds(16));
		if (!is_running)
			break;
	}
}

• 1.6 完整源码

#pragma once

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <vector>



std::mutex _mtx;
std::condition_variable _cv_not_full;
std::condition_variable _cv_not_empty;

const int max_queue_size_10 = 10;

enum
{
	// 总生产数目
	cnt_total_10 = 10,
};


template<typename T>
struct repo_
{
	// 用作互斥访问缓冲区
	std::mutex				_mtx_queue;

	// 缓冲区最大size
	unsigned int			_count_max_queue_10 = 10;

	// 缓冲区
	std::queue<T>			_queue;

	// 缓冲区没有满，通知生产者继续生产
	std::condition_variable _cv_queue_not_full;

	// 缓冲区不为空，通知消费者继续消费
	std::condition_variable _cv_queue_not_empty;



	// 用于生产者之间的竞争
	std::mutex				_mtx_pro;
	// 计算当前已经生产了多少数据了
	unsigned int			_cnt_cur_pro = 0;


	repo_(const unsigned int count_max_queue = 10) :_count_max_queue_10(count_max_queue)
		, _cnt_cur_con(0)

	{
		;
	}

	repo_(const repo_&instance) = delete;
	repo_& operator = (const repo_& instance) = delete;
	repo_(const repo_&&instance) = delete;
	repo_& operator = (const repo_&& instance) = delete;

};

template <typename T>
using repo = repo_<T>;





//----------------------------------------------------------------------------------------

// 生产者生产数据
template <typename T>
void thread_produce_item(const int &thread_index, repo<T>& param_repo, const T& repo_item)
{
	std::unique_lock<std::mutex> lock(param_repo._mtx_queue);

	// 1. 生产者只要发现缓冲区没有满， 就继续生产
	param_repo._cv_queue_not_full.wait(lock, [&] { return param_repo._queue.size() < param_repo._count_max_queue_10; });

	// 2. 将生产好的商品放入缓冲区
	param_repo._queue.push(repo_item);

	// log to console
	std::cout << "生产者" << thread_index << "生产数据：" << repo_item << "\n";

	// 3. 通知消费者可以消费了
	//param_repo._cv_queue_not_empty.notify_one();
	param_repo._cv_queue_not_empty.notify_one();
}


//----------------------------------------------------------------------------------------
// 消费者消费数据

template <typename T>
T thread_consume_item(const int thread_index, repo<T>& param_repo)
{
	std::unique_lock<std::mutex> lock(param_repo._mtx_queue);

	// 1. 消费者需要等待【缓冲区不为空】的信号
	param_repo._cv_queue_not_empty.wait(lock, [&] {return !param_repo._queue.empty(); });

	// 2. 拿出数据
	T item;
	item = param_repo._queue.front();
	param_repo._queue.pop();

	std::cout << "消费者" << thread_index << "从缓冲区中拿出一组数据:" << item << std::endl;

	// 3. 通知生产者，继续生产
	param_repo._cv_queue_not_full.notify_one();

	return item;
}


//----------------------------------------------------------------------------------------

/**
*  @ brief: 生产者线程
*  @ thread_index - 线程标识，区分是哪一个线程
*  @ count_max_produce - 最大生产次数
*  @ param_repo - 缓冲区
*  @ return - void

*/
template< typename T >
void thread_pro(const int thread_index, const int count_max_produce, repo<T>* param_repo)
{
	if (nullptr == param_repo || NULL == param_repo)
		return;
	

	while (true)
	{
		bool is_running = true;

		{
			// 用于生产者之间竞争
			std::unique_lock<std::mutex> lock(param_repo->_mtx_pro);

			// 缓冲区没有满，继续生产
			if (param_repo->_cnt_cur_pro < cnt_total_10)
			{
				thread_produce_item<T>(thread_index, *param_repo, param_repo->_cnt_cur_pro);
				++param_repo->_cnt_cur_pro;
			}
			else
				is_running = false;
		}

		std::this_thread::sleep_for(std::chrono::microseconds(16));
		if (!is_running)
			break;
	}
}



/**
*  @ brief: 消费者线程
*  @ thread_index - 线程标识，区分线程
*  @ param_repo - 缓冲区
*  @ return - void

*/
template< typename T >
void thread_con(const int thread_index, repo<T>* param_repo)
{
	if (nullptr == param_repo || NULL == param_repo)
		return;

	static int cnt_cur_con = 0;
	while (true)
	{
		bool is_running = true;
		{
			// std::unique_lock<std::mutex> lock(param_repo->_mtx_con);
			// 还没消费到指定的数目，继续消费
			if (cnt_cur_con < cnt_total_10)
			{
				thread_consume_item<T>(thread_index, *param_repo);
				++cnt_cur_con;
			}
			else
				is_running = false;

		}

		std::this_thread::sleep_for(std::chrono::microseconds(16));

		// 结束线程
		if ((!is_running))
			break;
	}
}


// 入口函数
//----------------------------------------------------------------------------------------

int main(int argc, char *argv[], char *env[])
{
	// 缓冲区
	repo<int> repository;
	// 线程池
	std::vector<std::thread> vec_thread;

	// 生产者
	vec_thread.push_back(std::thread(thread_pro<int>, 1, cnt_total_10, &repository));
	vec_thread.push_back(std::thread(thread_pro<int>, 2, cnt_total_10, &repository));

	// 消费者
	vec_thread.push_back(std::thread(thread_con<int>, 1, &repository));



	for (auto &item : vec_thread)
	{
		item.join();
	}

	return 0;
}

• 1.7 可能结果