C++11多线程编程---生产、消费者线程模型

#include<iostream>
#include<thread>
#include<list>
#include<mutex>
#include<condition_variable>
#include<queue>
#include<atomic>
using namespace std;

/*
线程内容:
一.怎么创建启动一个线程
std::thread定义一个线程对象，传入线程所需的线程函数和参数，线程自动开启
二.线程如何结束
子线程运行结束，线程就结束了
三.主线程如何处理子进程
t.join():等待t线程结束，当前线程继续往下运行
t.detach():把t线程设置为分离线程，主线程结束，整个进程结束，所有子线程自动结束了
*/
#if 0
void threadHandle1(int time)
{
	//让子线程睡眠time秒
	this_thread::sleep_for(chrono::seconds(time));

	cout << "hello threadHandle1" << endl;
}
void threadHandle2(int time)
{
	//让子线程睡眠time秒
	this_thread::sleep_for(chrono::seconds(time));

	cout << "hello threadHandle2" << endl;
}
int main()
{
	//创建了一个线程对象，传入一个线程函数，新线程就开始运行了
	thread t1(threadHandle1,2);
	thread t2(threadHandle2,3);

	//主线程运行完成，查看如果当前进程还有未运行完成的子线程，进行就会异常终止
	//主线程等待子线程结束，主线程继续往下运行
	t1.join();
	t2.join();
	//把子线程设置为分离线程
	//t1.detach();

	cout << "main threa done" << endl;
	

	return 0;
}
#endif
/*
线程间互斥  -》mutex
多线程程序
竟态条件：多线程程序执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同的运行结果
*/
#if 0

//模拟车站三个窗口卖票的程序
int TicketCount = 100;
mutex mtx;//全局的一把互斥锁

//模拟卖票的线程函数
void sellTicket(int index)
{
	
	while(TicketCount > 0) //锁+双重判断
	{
		//mtx.lock();
		{
			lock_guard<mutex>lock(mtx);//支持析构，防止死锁的发生
			
			//防止其它线程进入这个循环，从而前面的线程还未从1--到0的判断
			if (TicketCount > 0)
			{
				cout << "窗口：" << index << "卖出第：" << TicketCount << endl;
				TicketCount--;
			}
			
		}
		//mtx.unlock();
		this_thread::sleep_for(std::chrono::microseconds(100));
	}
		
}
	
int main()
{
	list<thread>tlist;
	for (int i = 1; i <= 3; ++i)
	{
		tlist.push_back(thread(sellTicket, i));
	}
	for (thread &t1 :tlist)
	{
		t1.join();
	}
	cout << "卖票结束:" << endl;
	return 0;
}
#endif

#if 0
mutex mtx;
condition_variable cv;
int main()
{
	//不可能用在函数参数传递或者返回过程中，只能用在简单的临界区代码的互斥操作中
	/*lock_guard<mutex>lgd(mtx);
	mtx.lock();
	mtx.unlock();

	lock_guard(const lock_guard&) = delete;
	lock_guard& operator=(const lock_guard&) = delete;
	*/

	//不仅可以使用在简单的临界区代码段的互斥操作中，还能用在函数调用中
	unique_lock<mutex>lck(mtx);
	cv.wait(lck);// =》#1.使线程进入等待状态 #2.lck.unlock可以把mtx给释放掉

	/*通知在cv上等待的线程，条件成立了，起来干活了！
	其它在cv上等待的线程，收到通知，从等待状态 =》 阻塞状态 =》 获取互斥锁了 =》 线程继续往下执行*/
	cv.notify_all();

	return 0;
}
#endif
#if 0
/*生产者，消费者线程模型*/

mutex mtx;
condition_variable cv;//定义条件变量，做线程间的同步通信操作

//生产者生产一个物品，通知消费者消费一个；消费完了，消费者再通知生产者生产
class Queue
{
public:
	void put(int val)//生产物品
	{
		unique_lock<mutex>lck(mtx);
		while (!que.empty())
		{
			//que不为空，生产者应该通过消费者去消费，消费完了，再继续生产
			//生产者线程#!1进入等待状态，并且#2把mtx互斥锁释放掉
			
			cv.wait(lck);
		}
		que.push(val);
		/*
		notify_one:通知另外的一个线程
		notify_all:通知其它所有的线程
		通知其它所有的线程，我生产了一个物品，你们赶紧消费吧
		其它线程得到该通知，就会从等待状态 =》 阻塞状态 =》 获取互斥锁才能继续执行
		*/
		cv.notify_all();
		cout << "生产者 生产：" << val << "号物品" << endl;
	}
	int get()//消费物品
	{
		unique_lock<mutex>lck(mtx);
		while (que.empty())
		{
			//消费者线程发现que是空的，通知生产线程先生产物品
			//#1 进入等待状态 #2把互斥锁mutex释放
			
			cv.wait(lck);
		}
		int val = que.front();
		que.pop();
		cv.notify_all();
		cout << "消费者 消费：" << val << "号物品" << endl;
		return val;
	}

private:
	queue<int> que;
};
void producer(Queue *que)//生产者线程
{
	for (int i = 1; i <= 10; i++)
	{
		que->put(i);
		this_thread::sleep_for(chrono::milliseconds(100));
	}
}
void consumer(Queue *que)//消费者线程
{
	for (int i = 1; i <= 10; i++)
	{
		que->get();
		this_thread::sleep_for(chrono::milliseconds(100));
	}
}
int main()
{
	Queue que;
	thread t1(producer,&que);
	thread t2(consumer,&que);


	t1.join();
	t2.join();
	return 0;
}
#endif