C++ | 多线程编程（三）条件变量

女爷i 2022-11-11 05:26 186阅读 0赞

条件变量：[https://zh.cppreference.com/w/cpp/thread/condition\_variable][https_zh.cppreference.com_w_cpp_thread_condition_variable]

condition\_variable 类是同步原语，能用于阻塞一个线程，或同时阻塞多个线程，直至另一线程修改共享变量（条件）并通知 condition\_variable 。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70]  
条件变量一般与互斥锁一起使用。

#### 三个线程轮流打印0~100. ####

目标：是三个线程分别依次打印1，2，3…100

#include <iostream>
    #include <thread>
    #include <mutex>				// 互斥量
    #include <condition_variable>	// 条件变量
    
    using namespace std;
    
    
    /*
    	// 版本一：不加信号量，互斥量，也可以完成，但会造成“空耗cpu”
    	例如在fun0中，不满足number%3==0条件，
    	则一直进行循环，直至线程时间片到达，切换线程
    */
    void fun0()	// 0  3
    {
        
    	while (number <= 100)
    	{
        
    		while (number % 3 == 0 && number <= 100)
    		{
        
    			cout << "t0_" << number << " ";
    			number += 1;
    		}
    		//cout << ".";
    	}
    }
    void fun1()	// 1  4
    {
        
    	while (number <= 100)
    	{
        
    		while (number % 3 == 1 && number <= 100)
    		{
        
    			cout << "t1_" << number << " ";
    			number += 1;
    		}
    		//cout << ".";
    	}
    }
    void fun2()	// 2  5
    {
        
    	while (number <= 100)
    	{
        
    		while (number % 3 == 2 && number <= 100)
    		{
        
    			cout << "t2_" << number << " ";
    			number += 1;
    		}
    		//cout << ".";
    	}
    }
    
    int main()
    {
        
    	thread t0(fun0);
    	thread t1(fun1);
    	thread t2(fun2);
    
    	t0.join();
    	t1.join();
    	t2.join();
    
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 1]

缺点：会使得CPU空耗大量时间。取消上边的`cout << ".";`注释可以看到cpu空耗情况。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 2]

#### 使用条件变量 ####

条件变量：
    	notify_one()（随机唤醒一个等待的线程）
    	notify_all()（唤醒所有等待的线程）
    
    	wait()是条件变量的成员函数，堵塞，等待唤醒
    		如果第二个参数lambda表达式返回值是false，
    		那么wait将解锁第一个参数（互斥量），并堵塞到本行。
    	堵塞到其他某个线程调用notify_one（）成员函数为止
    
    	notify_one();//尝试吧wait的线程唤醒，执行完这行，wait就被唤醒了
    	当其他notify_one()将wait唤醒之后，wait不断尝试获取互斥量锁，
    	如果获取不到，流程就卡在wait这里等着获取。
    	如果获取到了，wait就获取到锁（就等于上锁）；

这里存在一个问题，在下面的程序片段中，我们有Aa方案和Bb方案使用条件变量。

void fun0()	// 0  3
    {
        
    	unique_lock < std::mutex> locker(g_mtx);	// 唯一性锁
    	while (number <= 100)
    	{
        
    		while (number % 3 == 0 && number <= 100)
    		{
        
    			cout << "t0_" << number << " ";
    			number += 1;
    //			cv.wait(locker);	// 等待  A  ，A-a 先等待后唤醒
    			// 阻塞，等待其他线程唤醒
    			cv.notify_one();	// 唤醒	 B  ，B-b 先唤醒后等待
    			// 通知别的线程，唤醒其他线程
    		}
    		cout << ".a";
    //		cv.notify_one();	// 唤醒  a
    		cv.wait(locker);	// 等待  b
    	}
    	cv.notify_one();	// 唤醒最后一个阻塞线程
    }

等待和唤醒调用的时机很重要，如果我们使用Aa方案，那么可能会出现两种情况。

1.  第一个执行到此处的线程将会进入等待状态，而其他线程因为没要满足进入循环的条件将会空耗时间。
2.  三个线程刚好顺序执行，则三个线程最后都陷入了等待状态，但是由于没有额外的线程进行唤醒，会使得程序陷入循环等待状态。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 4]  
因此，我们需要使用Bb方案。

/*
    	// 版本二：加锁
    */
    void fun0()	// 0  3
    {
        
    	unique_lock < std::mutex> locker(g_mtx);	// 唯一性锁
    	while (number <= 100)
    	{
        
    		while (number % 3 == 0 && number <= 100)
    		{
        
    			cout << "t0_" << number << " ";
    			number += 1;
    			cv.notify_one();	// 唤醒	 B  ，B-b 先唤醒后等待
    			// 通知别的线程，唤醒其他线程
    		}
    		cout << ".";
    		cv.wait(locker);	// 等待  b
    	}
    	cv.notify_one();	// 唤醒最后一个阻塞线程
    }
    void fun1()	// 1  4
    {
        
    	unique_lock < std::mutex> locker(g_mtx);
    	while (number <= 100)
    	{
        
    		while (number % 3 == 1 && number <= 100)
    		{
        
    			cout << "t1_" << number << " ";
    			number += 1;
    			cv.notify_one();
    		}
    		cout << ".";
    		cv.wait(locker);
    	}
    	// 打印100，最后阻塞线程为fun1
    	cv.notify_one();
    }
    void fun2()	// 2  5
    {
        
    	unique_lock < std::mutex> locker(g_mtx);
    	while (number <= 100)
    	{
        
    		while (number % 3 == 2 && number <= 100)
    		{
        
    			cout << "t2_" << number << " ";
    			number += 1;
    			cv.notify_one();
    		}
    		cout << ".";
    		cv.wait(locker);
    	}
    	cv.notify_one();
    }
    
    int main()
    {
        
    	thread t0(fun0);
    	thread t1(fun1);
    	thread t2(fun2);
    
    	t0.join();
    	t1.join();
    	t2.join();
    
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 5]  
此方案依然存在问题。

*  问题1：唤醒的线程，如果不是我们需要的线程，就会空耗被唤醒线程直至再次唤醒其他线程，这个过程一直到我们需要的线程被唤醒。（有可能出现死锁情况）  
    // 在程序中，输出两个‘.’表示有空耗
 *  解决方案：使用 notify\_all 唤醒所有其他线程
 *  问题2：最后一个线程使用wait后，阻塞，不会有其他线程将其唤醒
 *  解决方案：在最后一个线程wait时，在其他的任意一个可以正常退出的线程中调用一次唤醒程序，比如打印100个数，fun1最后退出，可以在fun0，或fun2中调用一次唤醒函数

如下图所示出现死锁情况：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 6]

修改方案，使用notify\_all唤醒

/*
    	// 版本三：加锁
    	使用notify_all
    	线程退出时，调用一次唤醒函数
    */
    void fun0()	// 0  3
    {
        
    	unique_lock < std::mutex> locker(g_mtx);	// 唯一性锁
    	while (number <= 100)
    	{
        
    		while (number % 3 == 0 && number <= 100)
    		{
        
    			cout << "t0_" << number << " ";
    			number += 1;
    			//			cv.wait(locker);	// 等待  A  ，A-a 先等待后唤醒
    						// 阻塞，等待其他线程唤醒
    			cv.notify_all();	// 唤醒	 B  ，B-b 先唤醒后等待
    			// 通知别的线程，唤醒其他线程
    		}
    		cout << ".";
    		//		cv.notify_one();	// 唤醒  a
    		cv.wait(locker);	// 等待  b
    	}
    	cv.notify_all();	// 唤醒最后一个阻塞线程
    }
    void fun1()	// 1  4
    {
        
    	unique_lock < std::mutex> locker(g_mtx);
    	while (number <= 100)
    	{
        
    		while (number % 3 == 1 && number <= 100)
    		{
        
    			cout << "t1_" << number << " ";
    			number += 1;
    			cv.notify_all();
    		}
    		cout << ".";
    		cv.wait(locker);
    	}
    	// 打印100，最后阻塞线程为fun1
    	cv.notify_all();
    }
    void fun2()	// 2  5
    {
        
    	unique_lock < std::mutex> locker(g_mtx);
    	while (number <= 100)
    	{
        
    		while (number % 3 == 2 && number <= 100)
    		{
        
    			cout << "t2_" << number << " ";
    			number += 1;
    			cv.notify_all();
    		}
    		cout << ".";
    		cv.wait(locker);
    	}
    	cv.notify_all();
    }
    
    int main()
    {
        
    	thread t0(fun0);
    	thread t1(fun1);
    	thread t2(fun2);
    
    	t0.join();
    	t1.join();
    	t2.join();
    
    	return 0;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 7]

[https_zh.cppreference.com_w_cpp_thread_condition_variable]: https://zh.cppreference.com/w/cpp/thread/condition_variable
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70]: /images/20221022/81ceec3b833940c6bfc0cb3f2252d505.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 1]: /images/20221022/d5f4732eb5c64381a7a0c2595ee2abb9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210319153427458.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2021031915473098.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210319154623521.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210319155231721.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2021031915520429.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20210319160537337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkxOTkzMg==,size_16,color_FFFFFF,t_70