C++信号量condition_variable

目录

1、condition_variable

2、函数

3、测试

---

1、condition_variable

同步线程间的数据流依赖关系。

2、函数

Condition_variable cv;          构造
Cv.~Condition_variable();       销毁
Cv.notify_one();                唤醒一个等待者
Cv.notify_all();                唤醒所有的等待者
Cv.wait(ul);                    使用unique_lock ul来等待通知
Cv.wait(ul,pred);               使用unique_lock ul来等待通知，并直到pred在一次属性之后结果为true
Cv.wait_for(ul,duration);       使用unique_lock ul来等待通知，等待期限是duration
Cv.wait_for(ul,duration，pred); 使用unique_lock ul来等待通知，等待期限是duration或直到pred在一次苏醒之后结果为true
Cv.wait_until(ul,timepoint);    直到时间点
Cv.wait_until(ul,timepoint,pred);使用unique_lock ul来等待通知，直到时间点或直到pred在一次苏醒之后结果为true
Cv.native_handle();             返回一个因平台而异的类型native_handle_type，为的是不具有可移植性的扩展
Notify_all_at_thread_exit(cv,ul);在调用所在线程唤醒所有使用unique_lock ul来等待cv的线程

3、测试

#include <condition_variable>
#include <mutex>
#include <future>
#include <iostream>

using namespace std;

bool readyFlag;
mutex readyMutex;
condition_variable readyCondVar;

void threadOne()
{
	cout << "ThreadOne " << endl;
	cin.get();

	{
		lock_guard<mutex> lg(readyMutex);
		readyFlag = true;
	}
	//readyCondVar.notify_one();	//发出一个信号
	readyCondVar.notify_all();	//响应所有的等待信号
}

void threadTwo()
{
	{
		unique_lock<mutex> ul(readyMutex);
		readyCondVar.wait(ul, [] {return readyFlag; });
	}

	cout << "threadTwo" << endl;
}

void threadThree()
{
	{
		unique_lock<mutex> ul(readyMutex);
		readyCondVar.wait(ul, [] {return readyFlag; });
	}

	cout << "threadThree" << endl;
}
int main()
{
	auto f1 = async(launch::async, threadOne);
	auto f2 = async(launch::async, threadTwo);
	auto f3 = async(launch::async, threadThree);
	system("pause");
}