【C++多线程系列】【八】线程间通信之条件变量

最新推荐文章于 2022-06-19 22:51:51 发布
最新推荐文章于 2022-06-19 22:51:51 发布
阅读量430 收藏 2
点赞数
文章标签： c/c++ python
原文链接：https://my.oschina.net/u/3800567/blog/1805829
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

有如下场景：线程A需要等线程B完成操作后，再进行执行；在线程B完成操作前，线程A出于睡眠状态，当线程B完成操作后，唤醒线程A。这里，注意，在线程B完成前，A是处于睡眠状态，即此时，A不占用CPU，不可用原子变量+while死循环来等待（while（！done）），这样的话CPU会处于一直运行状态。

可以使用sleep来处理，但由于A不知道需要sleep多长时间，所以，sleep不合适。这里使用条件变量，来处理该问题。

条件变量：当收到notify通知时，检查是否满足某个条件，满足时，线程停止wait，被唤醒，重新加锁，继续执行。

整体流程如下图，具体见代码注释

220920_jeP6_3800567.png

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

// 使用条件变量的三剑客：
/*
1.互斥元
2.条件变量
3.条件值done
*/
mutex mA;
condition_variable cv;
bool done = false;

void f()
{
	unique_lock<mutex> _1(mA);
	// 条件变量的wait所必须是unique_lock而不是lock_guard，因为wait会在内部调用unique_lock.unlock先解锁，当被唤醒后，条件满足时，会unique_lock.lock
	// 条件为：当done为true时，收到notify的线程会被唤醒，否则即使收到notify，也不会被唤醒
	cv.wait(_1, [] {return done; });
	cout << "has done" << endl;

	// 需要手动释放锁
	_1.unlock();
}

void f2()
{
	// 这里使用lock_guard在mA上加锁即可
	lock_guard<mutex> _1(mA);
	cout << "f2" << endl;
	std::this_thread::sleep_for(1s);

	//必须将条件done设置为true，否则线程t1不会被唤醒
	done = true;

	//通知一个线程，让收到的线程检查其条件，收到通知的线程发现条件满足，则该线程会被唤醒
	cv.notify_one();
}


int main(int argc, int * argv[])
{
	thread t1(f);

	thread t2(f2);

	t1.join();
	t2.join();

	cout << "main" << endl;
	system("pause");
}

结果如下：

221037_S6zF_3800567.png

 

注意，如果在f2中，忘记将done 设置为 true，则f1不会被唤醒，会一直等待：

void f2()
{
	// 这里使用lock_guard在mA上加锁即可
	lock_guard<mutex> _1(mA);
	cout << "f2" << endl;
	std::this_thread::sleep_for(1s);

	//必须将条件done设置为true，否则线程t1不会被唤醒
	//done = true;

	//通知一个线程，让收到的线程检查其条件，收到通知的线程发现条件满足，则该线程会被唤醒
	cv.notify_one();
}

结果如下：

 

221222_d9e2_3800567.png

所以：条件变量的本质在于，只有当条件被满足时，线程才会被唤醒，而不是收到notify了，该等待线程就会被唤醒。

 

条件变量实际上实现了线程间的数据共享操作。线程A在修改完某些数据后，通过条件变量，来通知线程B来获取最新的数据修改值。

代码可以如下：

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

// 使用条件变量的三剑客：
/*
1.互斥元
2.条件变量
3.条件值done
*/
mutex mA;
condition_variable cv;
bool done = false;

int age = 0;

void f()
{
	unique_lock<mutex> _1(mA);
	// 条件变量的wait所必须是unique_lock而不是lock_guard，因为wait会在内部调用unique_lock.unlock先解锁，当被唤醒后，条件满足时，会unique_lock.lock
	// 条件为：当done为true时，收到notify的线程会被唤醒，否则即使收到notify，也不会被唤醒
	cv.wait(_1, [] {return done; });
	cout << "has done" << endl;
	cout << "age=" << age << endl;
	// 需要手动释放锁
	_1.unlock();
}

void f2()
{
	// 这里使用lock_guard在mA上加锁即可
	lock_guard<mutex> _1(mA);
	cout << "f2" << endl;
	std::this_thread::sleep_for(1s);

	age = 1000;
	//必须将条件done设置为true，否则线程t1不会被唤醒
	done = true;

	//通知一个线程，让收到的线程检查其条件，收到通知的线程发现条件满足，则该线程会被唤醒
	cv.notify_one();
}


int main(int argc, int * argv[])
{
	thread t1(f);

	thread t2(f2);

	t1.join();
	t2.join();

	cout << "main" << endl;
	system("pause");
}

age作为两个线程的共享变量，一个修改，一个使用修改后的值。

结果如下：

221834_jbiY_3800567.png

 

【坑】

在利用条件变量进行线程间等待与通知时，wait可以不用传递谓词，即判断条件函数。

这时，会有一个问题。如果线程A先notify，而线程B后wait，则线程B永远不会被唤醒。

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<future>
#include<chrono>
using namespace std;


mutex mA;
condition_variable cv;

void f()
{
	lock_guard<mutex> lock(mA);
	std::this_thread::sleep_for(1s);
	cv.notify_one();
	cout << "notify" << endl;
}

void f2()
{
	unique_lock<mutex> lock(mA);
	cout << "wait" << endl;
    // wait没有传入第二个参数
	cv.wait(lock);
	cout << "wake" << endl;
	lock.unlock();
}


int main(int argc, int * argv[])
{


	thread t1(f);  // 先notify
	thread t2(f2); // 后wait，一直等待，不会被唤醒

	t1.join();
	t2.join();

	cout << "main" << endl;
	system("pause");
}

结果如下：一直在wait，唤醒失败。

182021_dtz2_3800567.png

其实，这是一个先通知后等待的问题，如果先等待，后通知，则没有问题。

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<future>
#include<chrono>
using namespace std;


mutex mA;
condition_variable cv;

void f()
{
	lock_guard<mutex> lock(mA);
	std::this_thread::sleep_for(1s);
	cv.notify_one();
	cout << "notify" << endl;
}

void f2()
{
	unique_lock<mutex> lock(mA);
	cout << "wait" << endl;
	cv.wait(lock);
	cout << "wake" << endl;
	lock.unlock();
}


int main(int argc, int * argv[])
{


	
	thread t2(f2); // 先wait，
	thread t1(f);  // 后notify
	t1.join();
	t2.join();

	cout << "main" << endl;
	system("pause");
}

结果如下：线程正常被唤醒

182221_XP2u_3800567.png

 

如何解决这个问题呢？

方法一：给wait条件第二个参数，即谓词条件。

182338_Y28V_3800567.png

方法二：不给wait添加第二个参数，但是使用done标志位。当notify之后，该标志位设置为true。wait之前先判断该标志位。如果先通知，则该标志位为true，不会调用cv.wait，也就不会进入等待

#include<iostream>
#include<thread>
#include<mutex>
#include<condition_variable>
#include<future>
#include<chrono>
#include<atomic>
using namespace std;


mutex mA;
condition_variable cv;
atomic<bool> done(false);
void f()
{
	lock_guard<mutex> lock(mA);
	std::this_thread::sleep_for(1s);
	cv.notify_one();
	done = true;
	cout << "notify" << endl;
}

void f2()
{
	unique_lock<mutex> lock(mA);
	
	while (!done) {
		cout << "wait" << endl;
		cv.wait(lock);
	}
	
	cout << "wake" << endl;
	lock.unlock();
}


int main(int argc, int * argv[])
{


	thread t1(f);  // 先notify
	thread t2(f2); // 后wait，
	
	t1.join();
	t2.join();

	cout << "main" << endl;
	system("pause");
}

结果如下：

182743_SNmZ_3800567.png

 

其实，从本质上来说，方法一与方法二是相同的，看看vs2017里面的源码

182907_yqAi_3800567.png

 

所以，为了避免这种唤醒是失败的问题（失败的原因在于先notify后wait），最好使用第一种方法，这种做法简单，方便。逻辑上比第二种做法清晰。

转载于:https://my.oschina.net/u/3800567/blog/1805829

weixin_33913332
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++11多线程之条件变量
FinixLei的专栏 (https://github.com/FinixLei)
06-04 1万+
原文： http://en.cppreference.com/w/cpp/thread/condition_variable std::condition_variable 定义在头文件&lt;condition_variable&gt; class condition_variable; (since C++11) condition_variable类是一个同步原语，可以被用来阻...
Linux线程间通信-条件变量
qq_31193221的博客
01-01 526
Linux多线程通信学习之条件变量一、条件变量的介绍二、条件变量的创建和使用三、代码实例 从本篇开始对多线程通信的知识点进行整理，本篇主要介绍条件变量，有什么错误和建议请留言指教。有关前文多线程基础的整理请点此处。 一、条件变量的介绍 条件变量本质也是一个全局变量，它的功能是阻塞线程，直至接收到“条件成立”的信号后，被阻塞的线程才能继续执行。 #include <pthreadtypes.h> typedef union { struct __pthread_cond_s __data;
C++ 线程同步之条件变量
喜欢打篮球的普通人
06-19 904
条件变量是 C++11 提供的另外一种用于等待的同步机制，它能阻塞一个或多个线程，直到收到另外一个线程发出的通知或者超时时，才会唤醒当前阻塞的线程。condition_variable：需要配合 std::unique_lockstd::mutex 进行 wait 操作，也就是阻塞线程的操作。 condition_variable_any：可以和任意带有 lock()、unlock() 语义的 mutex 搭配使用，也就是说有四种：条件变量通常用于生产者和消费者模型，大致使用过程如下： （3）条件满足之后
10分钟，带你掌握C++多线程同步！
weixin_34018202的博客
04-25 1395
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例...
C++11多线程之互斥量(mutex)与条件变量(condition_variable)
A_L_A_N
03-21 5527
示例程序 条件变量和std::mutex合用，这是为了线程间通信。 #include <iostream> #include <string> #include <thread> #include <mutex> #include <condition_variable> std::mutex m; std::condition_variable cv; std::string data; bool ready = false; bool
c++通过结构体(struct)全局变量在多线程中传递参数
02-18
在实际应用中，可能还需要考虑线程局部存储（thread_local）、条件变量（condition_variable）等高级同步原语，以优化多线程间的通信和协作。此外，设计良好的并发代码应该尽量减少对全局状态的依赖，以提高可读性...
C++多线程网络聊天程序 .zip
07-12
C++提供多种同步工具，如互斥量（mutex）、条件变量（condition_variable）和信号量（semaphore），用于控制线程间的访问和通信，确保数据的一致性和安全性。 5. **网络编程**：在C++中，通常使用`<boost/asio>`库...
C++11 并发指南之多线程初探
12-20
5. **线程间通信**：虽然C++11的标准库没有提供直接的线程间通信机制，但可以通过`std::future`和`std::promise`实现异步计算和结果传递。 此外，C++11还引入了**右值引用**和**完美转发**，这些特性对于多线程环境...
c++多线程源码
02-05
C++多线程是现代C++编程中一个重要的特性，它允许程序同时执行多个任务，提高了程序的效率和响应性。在多核处理器系统中，多线程编程更是发挥着关键作用，能够充分利用硬件资源，实现并行计算。C++11及以后的标准...
C++实现多线程查找文件实例
09-04
通过这种方式，多线程查找文件实例展示了如何在C++中有效地利用多线程来并行处理任务，同时避免了竞态条件和死锁的问题。这种方法对于处理大量数据的I/O密集型任务非常有用，尤其是在Windows环境下。理解并熟练掌握...
C++多线程（6）之条件变量（std::condition_variable）
请叫我少爷的博客
10-21 584
条件变量（std::condition_variable） 这是c++11提供的一个类，用于多线程之间的通信。条件变量顾名思义就是根据不同条件而变化的量。 应用场景 这里举一个例子：有一个线程要求必须达到某种状态才能继续执行，否则将卡死在这里。在这种情况下我们有两种方案，第一种方案就是，在这个线程中不断去检测这个状态，直至符合条件。第二种方案就是，这个线程卡在这里不工作，当条件成立时，去通知...
使用线程间通信之条件变量
朱东宁的专栏
09-29 3138
最近用C++写安卓下的一个通讯程序，作为jni库给java调用，采用多线程轮询遇到一个问题描述如下： A线程收到数据，放入队列，是生产者。 B、C、D若干个线轮询训消息队列，如果队列有数据就取出进行处理，没数据就Sleep(T)休息，问题是这个T值取多大合适？取大了消息处理不及时，取小了手机cpu上升电池很快耗光。 这个问题最佳解法是采用条件变量，可以比较完美解决问题
线程间使用条件变量同步正确方式
mumumuwudi的博客
08-26 2050
线程间同步标准的使用方式如下： thread 1: pthread_mutex_lock(&mutex); while (!condition) pthread_cond_wait(&cond, &mutex); func_1();/* do something that requires holding the mutex and condi
【C/C++多线程编程之八】pthread条件变量
Jiangwei的专栏
05-03 7519
多线程编程之条件变量      Pthread是 POSIX threads 的简称，是POSIX的线程标准。         互斥机制，包括互斥量【C/C++多线程编程之六】pthread互斥量，信号量【C/C++多线程编程之七】pthread信号量，互斥能很好的处理共享资源访问的协调问题，是多线程同步必不可少的机制。互斥机制也有其缺陷，当线程在等待共享资源满足某个条件，
C++-线程同步基础之条件变量
mrbone11的博客
12-04 634
线程同步基础 并发场景下，有时我们并不仅仅想保护数据，我们还希望多个线程之间同步某些操作，例如等待某个条件为真或者某个事件发生时执行一些操作。C++标准库提供了条件变量（condition variables）和futures；并发技术规范（Concurrency Technical Specification (TS)）提供了latches和barriers。 条件变量 标准库中提供两种条件变量：std::condition_variable和std::condition_variable_any，它们
多线程——条件变量的概念和实现
glory的博客
09-16 1223
概念 条件变量，也称条件锁，是利用线程间共享的全局变量进行同步的一种机制， 主要包括两个动作： 1）一个线程等待"条件变量的条件成立"而挂起； 2）另一个线程使"条件成立"（给出条件成立信号）条件的检测是在互斥锁的保护下进行的如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。 如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。 如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步 函数API
Linux系统编程-(pthread)线程通信(条件变量)
01-12 512
条件变量是线程可用的一种同步机制，条件变量给多个线程提供了一个回合的场所，条件变量和互斥量一起使用，允许线程以无竞争的方式等待特定的条件发生。
线程间通信方法
TABE_的博客
01-10 690
这里写目录标题进程通信方法低级IPC常用于本机的IPC机制不同计算机上的IPC机制线程间通信方法 进程通信方法 低级IPC 文件：进程间通信可以通过传送打开文件（fork，exec与文件系统）来实现，不同的进程通过一个或多个文件来传递信息，事实上，在很多应用系统里，都使用了这种方法。 常用于本机的IPC机制 管道（pipe）：管道允许一个进程和另一个与它有共同祖先的进程之间进行通信。 命名管道（FIFO）：类似于管道，但是它可以用于任何两个进程之间的通信，命名管道在文件系统中有对应的文件名。命名管道通
深入理解C++多线程编程
"精通C++多线程" 本书《精通C++ Multithreading》由Maya Posch撰写，是一本全面指南，旨在帮助读者掌握在C++中开发高效多线程应用的技术。出版于2017年，由Packt Publishing发行，版权受保护，未经许可，不得复制或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值