C++多线程学习（三）——线程同步之条件变量

最新推荐文章于 2024-02-20 13:36:49 发布
最新推荐文章于 2024-02-20 13:36:49 发布
阅读量968 收藏 9
点赞数
分类专栏： 开源项目学习 文章标签： c++ linux 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32008381/article/details/121632690
版权

前面学习了互斥量似乎我们就可以多线程编程了，多线程也不过如此嘛。然而我们上手coding，用多线程来结局我们实际需求就会发现，似乎多线程也不是很好用。因为我们实际对于多线程的需求，往往线程都是while循环让其不断轮询执行，而不是简单的顺序命令执行完就结束线程了。让我们看个具体的例子深入感受下其中的痛点。

//cond_var1.cpp用互斥锁实现一个生产者消费者模型

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>

std::deque<int> q;						//双端队列标准容器全局变量
std::mutex mu;							//互斥锁全局变量
//生产者，往队列放入数据
void function_1() {
    int count = 10;
    while (count > 0) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);			//数据入队锁保护
        locker.unlock();
        std::this_thread::sleep_for(std::chrono::seconds(1));		//延时1秒
        count--;
    }
}
//消费者，从队列提取数据
void function_2() {
    int data = 0;
    int f2Count = 0;
    while ( data != 1) {
        f2Count++;
        std::unique_lock<std::mutex> locker(mu);
        if (!q.empty()) {			//判断队列是否为空
            data = q.back();
            q.pop_back();			//数据出队锁保护
            locker.unlock();
            std::cout << "t2 got a value from t1: " << data << std::endl;
            std::cout << "t2 run times " << f2Count << std::endl;
        } else {
            locker.unlock();
        }
    }
}

int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();

    getchar();
    return 0;
}

功能很简单，模拟最常见的收发多线程需求，压数据还好，1s往里面写一个数据，但是接收线程啥时候知道你啥时候有数据了呢？function_2线程就只能不断轮询了，看下执行结果，短短10s，轮询了3亿多次，cpu负荷拉满，我们生产要是写这种代码，老板分分钟鱿鱼套餐走起。

 一个简单的功能就把我们cpu占满了，那如何解决呢，聪明的同学已经知道了，定时轮询，cpu的轮询频率是很夸张的，现在好一点的都有几GHZ，那我们不依赖cpu轮询频率，增加线程休眠时间，别这么快，遭不住了，其实我看到的很多小公司对性能要求不高的程序确实都这么干的，虽简单，但有效。

上代码

//cond_var1.cpp用互斥锁实现一个生产者消费者模型

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>

std::deque<int> q;						//双端队列标准容器全局变量
std::mutex mu;							//互斥锁全局变量
//生产者，往队列放入数据
void function_1() {
    int count = 10;
    while (count > 0) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);			//数据入队锁保护
        locker.unlock();
        std::this_thread::sleep_for(std::chrono::seconds(1));		//延时1秒
        count--;
    }
}
//消费者，从队列提取数据
void function_2() {
    int data = 0;
    int f2Count = 0;
    while ( data != 1) {
        f2Count++;
        std::unique_lock<std::mutex> locker(mu);
        if (!q.empty()) {			//判断队列是否为空
            data = q.back();
            q.pop_back();			//数据出队锁保护
            locker.unlock();
            std::cout << "t2 got a value from t1: " << data << std::endl;
            std::cout << "t2 run times " << f2Count << std::endl;
        } else {
            locker.unlock();
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(50));		//延时50毫秒
    }
}

int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();

    getchar();
    return 0;
}

执行结果

 频率降到180了，对于绝大多数生产环境已经算是能接受了，但是也显而易见的，他的反应时间已经不是前面的几千万分之一秒了，而升高到了50ms，50ms似乎不长，但是对于一些对时间高敏感的fps游戏等需求呢？降低休眠时间？可行，但是cpu负荷增加，这时候我们就需要一个东西来满足休眠一个线程，直到符合某个条件时再继续往下执行，这样就不用再左右为难了。

C++标准库在< condition_variable >中提供了条件变量，借由它，一个线程可以唤醒一个或多个其他等待中的线程。原则上，条件变量的运作如下：

  • 你必须同时包含< mutex >和< condition_variable >，并声明一个mutex和一个condition_variable变量；
  • 那个通知“条件已满足”的线程（或多个线程之一）必须调用notify_one()或notify_all()，以便条件满足时唤醒处于等待中的一个条件变量；
  • 那个等待"条件被满足"的线程必须调用wait()，可以让线程在条件未被满足时陷入休眠状态，当接收到通知时被唤醒去处理相应的任务；

 上代码

//cond_var2.cpp用条件变量解决轮询间隔难题

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

std::deque<int> q;						//双端队列标准容器全局变量
std::mutex mu;							//互斥锁全局变量
std::condition_variable cond;           //全局条件变量
//生产者，往队列放入数据
void function_1() {
    int count = 10;
    while (count > 0) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);			//数据入队锁保护
        locker.unlock();
        
        cond.notify_one();              // 向一个等待线程发出“条件已满足”的通知
        
        std::this_thread::sleep_for(std::chrono::seconds(1));		//延时1秒
        count--;
    }
}
//消费者，从队列提取数据
void function_2() {
    int data = 0;
    while ( data != 1) {
        std::unique_lock<std::mutex> locker(mu);
        
        while(q.empty())        //判断队列是否为空
            cond.wait(locker); // 解锁互斥量并陷入休眠以等待通知被唤醒，被唤醒后加锁以保护共享数据

        data = q.back();
        q.pop_back();			//数据出队锁保护
        locker.unlock();
        std::cout << "t2 got a value from t1: " << data << std::endl;
    }
}

int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();

    getchar();
    return 0;
}

执行结果

 发送线程通知接收线程的时间损耗是多久呢，我们打印下收发时间

//cond_var2.cpp用条件变量解决轮询间隔难题
#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <time.h>



std::deque<int> q;						//双端队列标准容器全局变量
std::mutex mu;							//互斥锁全局变量
std::condition_variable cond;           //全局条件变量

//毫秒级时间戳
std::time_t getTimeStamp()
{
    std::chrono::time_point<std::chrono::system_clock,std::chrono::milliseconds> tp = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());//获取当前时间点
    std::time_t timestamp =  tp.time_since_epoch().count(); //计算距离1970-1-1,00:00的时间长度
    return timestamp;
}

//生产者，往队列放入数据
void function_1() {
    int count = 10;
    while (count > 0) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);			//数据入队锁保护
        time_t timestamp = getTimeStamp();
        locker.unlock();
        
        cond.notify_one();              // 向一个等待线程发出“条件已满足”的通知
        std::cout << "ptime:" << timestamp << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));		//延时1秒
        count--;
    }
}
//消费者，从队列提取数据
void function_2() {
    int data = 0;
    while ( data != 1) {
        std::unique_lock<std::mutex> locker(mu);
        
        while(q.empty())        //判断队列是否为空
            cond.wait(locker); // 解锁互斥量并陷入休眠以等待通知被唤醒，被唤醒后加锁以保护共享数据

        data = q.back();
        time_t timestamp = getTimeStamp();
        q.pop_back();			//数据出队锁保护
        locker.unlock();
        std::cout << "rtime:" << timestamp << std::endl;
        std::cout << "t2 got a value from t1: " << data << std::endl;
    }
}

int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();

    getchar();
    return 0;
}

 看运行结果，我们发现算上unlock()，通知以及切换线程、获取时间戳的总损耗控制再1ms以内，这完全可接受了。

 这样看来条件向量算是很优秀的控制切换方案了，但是使用上我是有个疑问的，function_2在调用cond.wait()之前是把mu锁住的，现在线程又阻塞在这里休眠没有unlock(),那function_1不是会死锁吗？为了模拟这种情况，我写了个例子，线程function_2，lock()后休眠1000s，实际function_1确实阻塞住了。

//cond_var1.cpp用互斥锁实现一个生产者消费者模型

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>

std::deque<int> q;						//双端队列标准容器全局变量
std::mutex mu;							//互斥锁全局变量
//生产者，往队列放入数据
void function_1() {
    int count = 10;
    while (count > 0) {
        std::unique_lock<std::mutex> locker(mu);
        q.push_front(count);			//数据入队锁保护
        locker.unlock();
        std::cout << "t1 push a value to q: " << count << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));		//延时1秒
        count--;
    }
}
//消费者，从队列提取数据
void function_2() {
    int data = 0;
    int f2Count = 0;
    while ( data != 1) {
        f2Count++;
        std::unique_lock<std::mutex> locker(mu);
        std::this_thread::sleep_for(std::chrono::seconds(1000));		//休眠1000s
        if (!q.empty()) {			//判断队列是否为空
            data = q.back();
            q.pop_back();			//数据出队锁保护
            locker.unlock();
            std::cout << "t2 got a value from t1: " << data << std::endl;
            std::cout << "t2 run times " << f2Count << std::endl;
        } else {
            locker.unlock();
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(50));		//延时50毫秒
    }
}

int main() {
    std::thread t1(function_1);
    std::thread t2(function_2);
    t1.join();
    t2.join();

    getchar();
    return 0;
}

 运行结果

 而前面的例子，我们可以看到cond.wait导致function_2阻塞后，并不影响function_1的执行，这里就可以知道，wait后的mutex锁，是可以被再次lock()往下执行的，而且wait被唤起往下执行的时候，是需要unlock掉wait前的锁定。实际上wait被调用时该mutex必须被unique_lock锁定，否则会发生不明确的行为。

正经的董同学
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【并发编程十】c++线程同步——条件变量（condition_variable）
junxuezheng的博客
01-03 761
简介：本篇文章，我们详细的介绍下c++标准库提供的线程同步方法中的第二个——条件变量（condition_variable）。
c++多线程之条件变量
William辰的博客
04-22 2808
1.条件变量condition_variable、wait（）、notify_one（）(通知一个线程) 1.1condition_variable实际上是一个类，是一个和条件相关的一个类，等待一个条件达成，这个类需要和互斥量来配合工作，用的时候我们要生成这个类的对象。 1.2.1wait()函数用于等待一个消息，他的第二个参数lambda表达式返回值是true，那wait（）直接返回，否则w...
[c++11]多线程编程(六)——条件变量(Condition Variable)
weixin_34007906的博客
09-02 324
互斥锁std::mutex是一种最常见的线程间同步的手段，但是在有些情况下不太高效。 假设想实现一个简单的消费者生产者模型，一个线程往队列中放入数据，一个线程往队列中取数据，取数据前需要判断一下队列中确实有数据，由于这个队列是线程间共享的，所以，需要使用互斥锁进行保护，一个线程在往队列添加数据的时候，另一个线程不能取，反之亦然。用互斥锁实...
c++多线程条件变量
zhuxincheng_1218的专栏
02-16 497
condition_variable处理线程间消息通讯 #include <condition_variable> using namespace std; mutex m; condition_variable cv; int main(){ thread **ps = new thread *[10];//开辟线程指针数组 for(int i= 0;i<10;i++){ ps[i] = new thread([](int index){
C++ | 多线程编程（三） 条件变量
专注于C/C++/Linux领域创作
03-19 505
条件变量：https://zh.cppreference.com/w/cpp/thread/condition_variable condition_variable 类是同步原语，能用于阻塞一个线程，或同时阻塞多个线程，直至另一线程修改共享变量（条件）并通知 condition_variable 。 条件变量一般与互斥锁一起使用。 三个线程轮流打印0~100. 目标：是三个线程分别依次打印1，2，3…100 #include <iostream> #include <thread&gt
多线程之条件变量
fzl_blog的博客
08-05 648
在C++11可以使用条件变量（condition_variable）实现多个线程间的同步操作；当条件不满足时，相关线程被一直阻塞，直到某种条件出现，这些线程才会被唤醒。 主要成员函数： 1、wait函数： （1）wait（unique_lock <mutex>＆lck） 没有第二个参数收到notify时直接返回不阻塞 当前线程的执行会被阻塞，直到收到 notify 为止。 （2）wait（unique_lock <mutex>＆lck，Predicate pred） 当前
C++多线程并发（三）---线程同步之条件变量
热门推荐
流云
05-03 1万+
一、何为条件变量 在前一篇文章《C++多线程并发编程（二）—线程同步之互斥锁》中解释了线程同步的原理和实现，使用互斥锁解决数据竞争访问问题，算是线程同步的加锁原语，用于排他性的访问共享数据。我们在使用mutex时，一般都会期望加锁不要阻塞，总是能立刻拿到锁，然后尽快访问数据，用完之后尽快解锁，这样才能不影响并发性和性能。 如果需要等待某个条件的成立，我们就该使用条件变量(condition var...
C++多线程中的锁和条件变量使用教程
08-26
在C++多线程编程中，锁和条件变量是两个非常重要的概念，它们都是用于解决多线程之间的同步和通信问题的。下面我们将详细地介绍锁和条件变量的使用。 一、锁（Mutex） 锁是多线程编程中最基本的同步机制，它用于...
c++多线程同步——信号量
04-27
在C++编程中，多线程同步是一种关键的技术，它允许多个执行线程协同工作，以避免数据竞争和死锁等并发问题。信号量（Semaphore）是实现多线程同步的一种有效工具，常用于控制对共享资源的访问。在这个名为"Mthread11...
C++ 多线程学习(3) ---- 条件变量
小猪佩奇的博客
06-30 6806
比如上面的代码中如果不加锁保护，在判断 mDisplayQueue.empty() 的条件成立后，此时线程被挂起，调度了另一个线程，另外的线程用于唤醒这个 condition_variable，此时当前线程因为还没有处于 wait 状态上（没有处于调度器的等待队列上），所以会丢失掉这个唤醒操作，如果这个唤醒操作只有一次，那么当前线程很可能永远处于阻塞等待的状态上。要解决该问题，就必须让生产者在缓冲区满时休眠，等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。
C++ 线程同步之条件变量
喜欢打篮球的普通人
06-19 927
条件变量是 C++11 提供的另外一种用于等待的同步机制，它能阻塞一个或多个线程，直到收到另外一个线程发出的通知或者超时时，才会唤醒当前阻塞的线程。condition_variable：需要配合 std::unique_lockstd::mutex 进行 wait 操作，也就是阻塞线程的操作。 condition_variable_any：可以和任意带有 lock()、unlock() 语义的 mutex 搭配使用，也就是说有四种：条件变量通常用于生产者和消费者模型，大致使用过程如下： （3）条件满足之后
C++多线程同步之条件变量
beibeix2015的博客
03-04 172
Condition variable 条件变量对象能够阻塞线程的调用直到通知其重启。 Member functions 构造函数，构造一个条件变量对象，条件变量对象不能被拷贝构造、移动拷贝构造。 析构函数，释放一个条件变量对象，任何处于阻塞状态的线程中的条件变量对象在没有被通知前都不能调用析构；任何线程不能在已经析构了的条件变量对象上调用阻塞。 Wait functions wait，等待直到被通知。 wait_for，等待超时或者被通知。 wait_until，等待直到被通知或到某个时间点
多线程编程【条件变量】
smf12138的博客
11-26 1225
调用时，这个互斥量是已上锁状态. wait的职责是释放锁，并让调用线程休眠（原子地）.当线程被唤醒时（即另外某个线程发信号给它后），它必须重新获取锁，再返回调用者，这是为了避免线程在陷入休眠时，产生一些。尽管不是所有情况都严格需要，但有效且简单的做法，还是在使用条件变量发送信号时持有锁，虽然上面的例子是必须加锁的情况，但也有一些情况可以不加锁，但为了简单，请在调用。让我们来看看生产者和消费者之间的信号逻辑，当生产者想要填充缓冲区时，它等待缓冲区变空，消费者具有完全相同的逻辑，但等待不同的条件-变满.
C++多线程6-条件变量
m0_37582216的博客
10-16 214
1.条件变量 std::condition_variable是多线程中经常用到的一个类，它的头文件为condition_variable。它常用的成员函数包括，wait,notify_one,notify_all等。它通过wait函数进行条件判断是否阻塞，当wait阻塞后由notify_one,notify_all函数进行唤醒。 2.wait成员函数 wait的函数它有两个形参，第二个形参可选(默...
多线程编程——条件变量
我云的博客
12-11 222
#include &amp;lt;pthread.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;unistd.h&amp;gt; #include &amp;lt;stdio.h&amp;gt; /* 静态方式初始化一个互斥锁和一个条件变量 */ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
c++11 多线程支持 条件变量（condition_variable）（三）
qq_40788199的博客
08-20 983
条件变量是允许多个线程相互交流的同步原语。它允许一定量的线程等待（可以定时）另一线程的提醒，然后再继续。条件变量始终关联到一个互斥。
219-C++多线程(条件变量)
LINZEYU666的博客
03-11 833
操作1（不加线程） 操作2（引入多线程） 打印的结果不是我们想要的！ 这里造成结果混乱的原因是什么？ 原因是： 并发执行，多线程抢占资源。 这是一种异步执行方案。当我们程序链接编译通过之后，我们从主函数开始执行，我们将分配相应的内存区域（用户空间区）：代码区，数据区，堆区，栈区。主函数运行，主线程产生，我们在这里定义一个数组，定义5个对象，但是这些对象没有被初始化，不是我们真正意义上的线程对象，是不可被执行。我们在for循环中，依次初始化线程对象，分配相对应的栈帧空间和线程信息。建立这5个线程之后
4. C++ 线程同步之条件变量
最新发布
谢谢大家的关注
02-20 946
类的 wait() 还有一个重载的方法，可以接受一个条件，这个条件也可以是一个返回值为布尔类型的函数，条件变量会先检查判断这个条件是否满足，如果满足条件（布尔值为true），则当前线程重新获得互斥锁的所有权，结束阻塞，继续向下执行；函数和 wait() 的功能是一样的，只不过多了一个阻塞时长，假设阻塞的线程没有被其他线程唤醒，当阻塞时长用完之后，线程就会自动解除阻塞，继续向下执行。，直到收到另外一个线程发出的通知或者超时时，才会唤醒当前阻塞的线程。条件变量是 C++11 提供的另外一种用于等待的同步机制，
C++多线程编程：条件变量与线程同步
条件变量是C++多线程编程中的一个重要概念，它在并发控制中发挥着关键作用。在多核软件开发技术中，条件变量与互斥锁（mutex）一起使用，确保线程之间的协作不会导致数据竞争或死锁。当一个线程需要等待特定条件满足...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值