同步并发操作之等待一个事件或条件

两个线程需要同步操作时，可以设置一个全局变量，用互斥量保护这个全局变量，通过这个全局变量来同步。

但是这样太浪费CPU，这时可以用休眠方法。

bool flag;
std::mutex m;

void wait_for_flag()
{
	std::unique_lock<std::mutex> lk(m);
	while(!flag)
	{
		lk.unlock();
		//休眠期间，其他线程可以操作flag
		std::this_thread::sleep_for(std::chrono::milliseconds(100));
		lk.lock();
	}
}

但是很难确定休眠时间的长短，太长或太短都不合理。

在C++库中，可以使用条件变量（condition variable）。条件变量可以和事件或条件结合起来，一个或多个线程等待时间或条件。当事件到达货事件满足后，使用nofify通知等待的线程。

下面看一个例子，生产者号消费者：

#include<iostream>
#include<mutex>
#include<condition_variable>
#include<queue>
#include<thread>
#include<Windows.h>//VS2013调试用的

std::mutex mut;
std::queue<int> q;
std::condition_variable cond;

void data_preparation_thread()
{
	while (true)
	{
		//休眠一下
		Sleep(1000);//1s
		int data = rand() % 20;
		std::lock_guard<std::mutex> lk(mut);
		q.push(data);
		std::cout << "Preparation Data:" << data << std::endl;
		cond.notify_one();//唤醒一个，notify_any()唤醒所有
	}
}

void data_processing_thread()
{
	while (true)
	{
		Sleep(2000);//2s
		std::unique_lock<std::mutex> lk(mut);
		/*
		wait先检查lambda表达式，如果满足条件则返回。否则就等待，此时unlock mut然后线程阻塞。
		当线程被唤醒，会重新lock mut，并检查lambda表达式。如果lambda不满足，那么unlock mut继续等待。
		所以上面要有unique_lock
		*/
		cond.wait(lk, []{return !q.empty(); });//lambda function，等待的条件[]{return !q.empty(); }
		int data = q.front();
		q.pop();
		lk.unlock();
		std::cout << "Processing Data:" << data << std::endl;
	}
}
int main()
{
	std::thread t1(data_preparation_thread);
	std::thread t2(data_processing_thread);
	t1.join();
	t2.join();
	return 0;
}

下面使用条件变量编写一个线程安全的队列

#include<queue>
#include<condition_variable>
#include<mutex>
#include<memory>

template<typename T>
class threadsafe_queue
{
private:
	mutable std::mutex mut;//在const函数中使用
	std::queue<T> data_queue;
	std::condition_variable data_cond;
public:
	threadsafe_queue()
	{}
	threadsafe_queue(threadsafe_queue const& other)
	{
		std::lock_guard<std::mutex> lk(other.mut);
		data_queue = other.data_queue;
	}
	void push(T new_value)
	{
		std::lock_guard<std::mutex> lk(mut);
		data_queue.push(new_value);
		data_cond.notify_one();//如果多个线程等待，可以使用nofity_all()
	}
	void wait_and_pop(T& value)
	{
		std::unique_lock<std::mutex> lk(mut);
		data_cond.wait(lk, [this]{return !data_queue.empty(); });
		valuue = data_queue.front();
		data_queue.pop();
	}

	std::shared_ptr<T> wait_and_pop()
	{
		std::unique_lock<std::mutex> lk(mut);
		data_cond.wait(lk, [this]{return !data_queue.empty(); });
		std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
		data_queue.pop();
		return res;
	}

	bool try_pop(T& value)
	{
		std::lock_guard<std::mutex> lk(mut);
		if (data_queue.empty())
			return false;
		value = data_queue.front();
		data_queue.pop();
		return true;
	}
	std::shared_ptr<T> try_pop()
	{
		std::lock_guard<std::mutex> lk(mut);
		if (data_queue.empty())
			return std::shared_ptr<T>();
		std::shared_ptr<T> res(std::make_shared<T>(data_queue.front()));
		data_queue.pop();
		return res;
	}
	bool empty() const
	{
		std::lock_guard<std::mutex> lk(mut);
		return data_queue.empty();
	}

};