C++线程同步-条件变量(std::condition_variable)

        线程同步是指线程间需要按照预定的先后次序顺序进行的行为。一个线程的执行需要依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,知道消息到达才被唤醒。

条件变量(std::condition_variable)

        C++11中新增了对条件变量的支持,当std::condition_variable对象的某个wait函数被调用的时候,它使用std::unique_lock(std::mutex)来锁住当前线程,当前线程会一直被阻塞,直到另外一个线程在同一个std::condition_variable对象上调用notify(one or all)来唤醒当前线程。

#include <iostream>               
#include <thread>                
#include <mutex>                
#include <condition_variable>    
 
std::mutex mtx; .
std::condition_variable cv; 
bool flag = false; 
 
void doSomething(int event)
{
	std::unique_lock <std::mutex> ulock(mtx);
 
	while (!flag)
	{
		/*
			如果flag不为 true,当前线程被阻塞, 当flag变为 true 之后, 线程被唤醒, 继续往下执行,会打印当前的event.
		*/
		cv.wait(ulock);
	}
	std::cout << "do " << event << std::endl;
}
 
void wake()
{
	std::unique_lock <std::mutex> lck(mtx);
	flag = true; // 设置flag为 true.
	cv.notify_all(); // 唤醒所有线程.
}
 
int main()
{
	std::thread threads[5];
	
	for (int i = 0; i < 5; ++i)
		threads[i] = std::thread(doSomething, i);
 
	std::cout << "5 threads running...\n";
	wake(); 
 
	for (auto & th : threads)
		th.join();
 
	return 0;
}

std::condition_variable::wait()函数

unconditional   void wait(std::unique_lock<std::mutex>& lock);
predicate                template< class Predicate > void wait( std::unique_lock< std::mutex >& lock, Predicate stop_waiting );

        在当前线程调用wait()后将被阻塞(此时当前线程已经获得了mutex锁),直到另一个线程调用notify唤醒当前线程。在线程被阻塞时,wait()函数会主动调用mutex锁的.unlock()来释放锁,使得其他阻塞在这个锁上面的进程可以继续执行。另外,在其他线程调用notify唤醒当前线程后,wait()函数也会主动调用mutex锁的.lock()来保持mutex锁的状态与wait()被调用时保持一致。

        在设置了Predicate的情况下,只有当stop_waiting条件为false时调用wait()才会阻塞当前线程,并且在收到其他线程的通知后只有当stop_waiting条件为true时才会被解除则塞。

        第二种情况的示例如下:

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

std::mutex mtx;
std::condition_variable cv;

int ready = 0;
bool isReady()
{
    return ready != 0;
}

// 消费者线程.
void consume(int n)
{
    for (int i = 0; i < n; ++i) {
        std::unique_lock <std::mutex> lock(mtx);
        cv.wait(lock, isReady);
        std::cout << ready << '\n';
        ready = 0;
    }
}

int main()
{
    std::thread consumer_thread(consume, 10); // 消费者线程.

    // 主线程为生产者线程, 生产 5 个产品.
    for (int i = 0; i < 5; ++i) {
        while (isReady())
            std::this_thread::yield();
        std::unique_lock <std::mutex> lck(mtx);
        ready = i + 1;
        cv.notify_one();
    }

    consumer_thread.join();

    return 0;
}

std::condition_variable::notify_one函数

         std::condition_variable的实现中有一个等待队列来保存阻塞在它之上的线程。       

         std::condition_variable::notify_one:唤醒等待队列中的某个等待(wait)线程。如果当前没有等待线程,则该函数什么也不做,如果同时存在多个等待线程,则唤醒某个线程是不确定的

std::condition_variable::notify_all函数

        std::condition_variable::notify_all:唤醒等待队列中所有的线程

std::condition_variable::wait_for()函数  

unconditionaltemplate <class Rep, class Period>
  cv_status wait_for (unique_lock<mutex>& lck,
                      const chrono::duration<Rep,Period>& rel_time);
predicate   template <class Rep, class Period, class Predicate>
       bool wait_for (unique_lock<mutex>& lck,
                      const chrono::duration<Rep,Period>& rel_time, Predicate pred);

        从功能上来说和wait()相似,但是wait_for()可以指定一个时间段,如果当前线程收到通知前或者指定时间超时前,都会处于阻塞状态,而在超时或者收到其他线程的通知后,wait_for()将返回。

        wait_for第2个版本的最后一个参数表示wait_for的预测条件,只有当pred为false时调用wait_for()才会阻塞当前线程,在收到其他线程的通知后,只有pred为true时,才会唤醒当前线程。

std::condition_variable::wait_until()函数 

unconditionaltemplate <class Clock, class Duration> cv_status wait_until (unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time); 
predicatetemplate <class Clock, class Duration, class Predicate> bool wait_until (unique_lock<mutex>& lck, const chrono::time_point<Clock,Duration>& abs_time, Predicate pred);

        与wait_for类似,只是wait_until函数是指定了一个时间点

     
 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值