【cpp学习笔记】多线程编程

已于 2022-06-05 15:15:34 修改
阅读量1.4k 收藏 5
点赞数
文章标签： c++
于 2022-04-23 11:59:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42108183/article/details/124361851
版权

1、前言

在学习利用多线程来实现多模型的目标检测时，接触到了 condition_variable、future等多线程编程知识，感觉自己对这方面的知识还不熟悉，于是便找了一些学习资料进行学习。

2、学习内容

2.1、生产者消费者模型

如果只考虑一个生产者和一个消费者线程，生产者线程不停的在队列q中添加值，消费者线程不停的在队列中去除值，此时可以采用条件变量来唤醒消费者线程，当消费者线程判断队列为空时，释放锁，并cv.wait()。而生产者线程增加一个值后，就会使用cv.notify_one()随机的唤醒一个线程，因为这里只有一个线程，cv.notify_one() 和 cv.notify_all() 的功能一致。但是如果有多个消费者线程，则会出现问题。

#include<stdio.h>
#include<thread>
#include<queue>
#include<mutex>
#include<string>
#include<chrono>
#include<iostream>
#include<condition_variable>
#include<future>

using namespace std;

condition_variable cv;

mutex mtx;
deque<int>q;

void task1(){
    int i=0;
    while(true){
        unique_lock<mutex> lock(mtx);
        q.emplace_back(i);
        cv.notify_one();
        // cv.notify_all();
        //每次生产出一个数据后，就去唤醒 cv_wait
        if(i<999999){
            i++;
        }
        else{
            i=0;
        }
    }
}

void task2(){
    int data = 0;
    while(true){
        unique_lock<mutex>lock(mtx);

        //如果队列为空，就利用wait进入休眠状态,同时释放锁,被唤醒时加锁
        if(q.empty()){
            cv.wait(lock);
        }
        if(!q.empty()){
            data = q.front();
            q.pop_front();
            cout<<"Get value from que:"<<data<<endl;
        }
    }
}


void task2(){
    int data = 0;
    while(true){
        unique_lock<mutex>lock(mtx);

        //如果队列为空，就利用wait进入休眠状态,同时释放锁,被唤醒时加锁
        if(q.empty()){
            cv.wait(lock);
        }
        if(!q.empty()){
            data = q.front();
            q.pop_front();
            cout<<"Get value from que:"<<data<<endl;
        }
    }
}

// void task3(){
//     int data = 0;
//     while(true){
//         unique_lock<mutex>lock(mtx);

//         //如果队列为空，就利用wait进入休眠状态,同时释放锁,被唤醒时加锁
//         if(q.empty()){
//             cv.wait(lock);
//         }

//         if(!q.empty()){
//             data = q.front();
//             q.pop_front();
//             cout<<"Get value from que:"<<data<<endl;
//         }
//     }
// }


int main(){

    thread t1(task1);
    thread t2(task2);

    if(t1.joinable())
        t1.join();
    if(t2.joinable())
        t2.join();
    // if(t3.joinable())
    //	t3.join();
    return 0;
}

2.2、功能优化

考虑以下场景，当有一个生产者线程和两个消费者线程时，队列中只有一个元素，消费者线程2处理wiat状态，消费者1取出q中的元素正常进行打印，然后进入到下一个循环中并拿到锁，此时生产者线程增加一个元素，并随机的唤醒了消费者线程2，但是此时消费者线程拿到了锁并取出值并打印，此时消费者线程再去队列中拿值时就会引发异常，此时只需要将 其中的if修改为while,while会多次检查队列是否为空

#include<stdio.h>
#include<thread>
#include<queue>
#include<mutex>
#include<string>
#include<chrono>
#include<iostream>
#include<condition_variable>
#include<future>

using namespace std;

condition_variable cv;

mutex mtx;
deque<int>q;


//生产者线程
void prod(){
    int i=0;
    while(true){
        unique_lock<mutex> lock(mtx);
        q.emplace_back(i);
        
        //随机唤醒某一个线程
        cv.notify_one();

        // 去唤醒所有线程
        // cv.notify_all();

        //每次生产出一个数据后，就去唤醒 cv_wait
        if(i<999999){
            i++;
        }
        else{
            i=0;
        }
    }
}

//消费者线程1
void con1(){
    int data = 0;
    while(true){
        unique_lock<mutex>lock(mtx);

        //如果队列为空，就利用wait进入休眠状态,同时释放锁,被唤醒时加锁
        while(q.empty()){
            //可能有多个线程调用了这个cv_wait，所以会导致报错
            cv.wait(lock);
            //含义如下，
            //lock.unlock()
                //cv.wait()
        }

        data = q.front();
        q.pop_front();
        cout<<"Get value from que:"<<data<<endl;
    }
}


//消费者线程2
//如果此时增加了一个消费者线程,将会出现问题

//虚假唤醒问题  即队列为空，但是消费者线程却被唤醒了，去取队列里面的值，就报错了、
//发生错误的情形如下:
//在线程1中，此时队列q中有一个值，线程1正常pop，然后打印，接着进入到下一个循环，运行到 unique_lock<mutex>lock(mtx);时
//此时队列 元素+1,然后随机的唤醒了线程2,但此时线程1拥有队列的锁，于是线程1拿到了队列中的值，然后进行的pop，此时队列为空，
//此时线程2再去拿队列中的值，就会发生异常,只需要将 if 修改为while

void con2(){
    int data = 0;
    while(true){
        unique_lock<mutex>lock(mtx);

        //如果队列为空，就利用wait进入休眠状态,同时释放锁,被唤醒时加锁
        while(q.empty()){
            cv.wait(lock);
        }
        data = q.front();
        q.pop_front();
        cout<<"Get value from que:"<<data<<endl;
    }
}

int main(){

    thread t1(prod);
    thread t2(con1);
    thread t3(con2);
    if(t1.joinable())
        t1.join();
    if(t2.joinable())
        t2.join();
    if(t3.joinable())
        t3.join();
    return 0;
}

2.3 future、promise

如果需要获得线程中的值，可以采用条件变量等待子线程结束，再打印想要的值

#include<stdio.h>
#include<thread>
#include<queue>
#include<mutex>
#include<string>
#include<chrono>
#include<iostream>
#include<condition_variable>
#include<future>

using namespace std;

mutex mtx;
condition_variable cv;

void task(int a,int b, promise<int>& ret){
    int ret_a = a * a;
    int ret_b = b * 2;
    ret = ret_a + ret_b;
    cv.notify_one();
}

//这个版本导致代码太多,使用future可以优雅的解决

int main(){
    int ret = 0;
    //如果需要传递引用，则需要加ref

    //将p传递进去
    thread t(task,1,2,ref(ret));

    unique_lock<mutex>lock(mtx);
    //等待线程通知，然后往下执行
    cv.wait(lock);
    cout<< "return value is" << ret<<endl;
    if(t.joinable())
        t.join();

}

上述这种方式可以使用future更为优雅的解决

#include<stdio.h>
#include<thread>
#include<queue>
#include<mutex>
#include<string>
#include<chrono>
#include<iostream>
#include<condition_variable>
#include<future>

using namespace std;


void task(int a,int b,  promise<int>& ret){
    int ret_a = a * a;
    int ret_b = b * 2;

    ret.set_value(ret_a+ret_b);

}

//这个版本导致代码太多,使用future可以优雅的解决

int main(){
    int ret = 0;

    promise<int>p;
    future<int>f = p.get_future(); //将f与p关联起来
    
    thread t(task,1,2,ref(p));

    //f.get()会阻塞在这里等待 p给f传递值，且f.get()只能用一次
    cout <<"return ret is :" << f.get() <<endl;
    if(t.joinable())
        t.join();

}

如果使用多个子线程，但其中 f.get()只能只用一次，此时可以使用 share_future

#include<stdio.h>
#include<thread>
#include<queue>
#include<mutex>
#include<string>
#include<chrono>
#include<iostream>
#include<condition_variable>
#include<future>

using namespace std;


void task(int a, future<int>&b,  promise<int>& ret){
    int ret_a = a * a;
    //等待主线程的p_in 设置号值之后再继续
    int ret_b = b.get()* 2;

    ret.set_value(ret_a+ret_b);

}

//有时候 在给线程传值是,可能不需要立马传递值,可能需要过一段时间传递值

int main(){
    int ret = 0;

    promise<int>p_ret;
    future<int>f_ret = p_ret.get_future();
	
	//延时传值
    promise<int>p_in;
    future<int>f_in = p_in.get_future();

    thread t(task,1,ref(f_in),ref(p_ret));
    
    //do

    p_in.set_value(8);
     
    //

    cout <<"return ret is :" << f_ret.get() <<endl;
    if(t.joinable())
        t.join();

}

2.4、功能优化

上诉方法可以通过系统函数写的更为简洁

#include<stdio.h>
#include<thread>
#include<queue>
#include<mutex>
#include<string>
#include<chrono>
#include<iostream>
#include<condition_variable>
#include<future>

using namespace std;


int task(int a,int b){
    int ret_a = a * a;
    //等待主线程的p_in 设置号值之后再继续
    int ret_b = b * 2;
    return ret_a+ret_b;
}

//为了简化上述方法，可以使用async

int main(){

    //使用async可以在线程中获得返回值
    //async不一定创建新的线程做计算，如果使用launch::async则会开启新的线程
    //launch::deferred 为延迟调用,当有fu.get()时，才会开启线程
    future<int> fu = async(launch::async,task,1,2);
    cout <<"return ret is :" << fu.get() <<endl;

}

3、总结

本次多多线程学习主要学习了条件变量、futrue、pormise的使用方法，希望在工作中处理多线程时，能够更优雅的解决问题。

Rex久居
关注
Cpp-多线程简述
Cutepingping的博客
01-27 2553
Cpp-多线程简述 对于多线程而言是所有程序的利器，所以多线程是比较关键的。 在C++11中，引入了thread这个库函数，所以对于线程操作就比较简单。 一、定义线程 void thread01() { for (int i = 0; i < 5; i++) { std::cout << "Thread 01 is working!" << std::endl; Sleep(1
c++多线程
aocenmin8777的博客
08-02 507
C++ 多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。 基于线程的多任务处理是同一程序的片段的并发执行。 多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 本...
CPP学习第一天
最新发布
luoxuezhixing的博客
07-17 542
学习Cpp的第一天
多线程Cpp
Destiny_的博客
05-21 3485
文章目录0.基本概念1.进程2.线程3.并发3.1 多进程并发3.2 多线程并发4.jion()5.detach()6.jionable()7.注意8.粒度1.线程休眠2.启动线程3.传递参数3.1传递临时对象作为线程参数4.线程id5.传递类对象、智能指针、类成员函数和类对象作为线程参数5.1 传递类对象5.2 传递智能指针5.3 类成员函数5.3 类对象6.数据共享问题：6.1 只读数据6.2 读写数据7.互斥量7.1 互斥量的使用7.2 std::lock_guard()8.死锁8.1概念8.2 死锁
CPP多线程
点云兔子的博客
06-16 1209
多线程是一种允许程序同时运行多个线程的技术。每个线程可以执行不同的任务，这在处理需要并发执行的操作时（例如，处理多个客户端的网络服务器，或者图形用户界面应用程序）非常有用。多线程能够提高程序的性能和响应速度。
Cpp多线程（一）
BUAAer_xuyang的博客
01-17 1111
对于thread构造函数，其第一个参数为所执行函数的名称（可能是引用），后面的参数则为所执行函数的参数。对于线程，C++用类来描述，创建了一个Thread类的对象，即是新增了一个线程。上面这个例子，我们可以说吗，托thread1的福，thread2也得以运行完毕，但是如果thread2运行得慢一点，那么thread2依旧无法执行完毕。可以看出，位于join之前的one和two还是可以被打印的，而three要等到thread1和thread2执行完毕，才被打印。上面这张图就解释了线程和多线程的意义。
CPP 学习笔记-多线程
devil_1995的博客
01-02 401
知识点１ Linux 下编译 带<thread> 的CPP需要加上 -pthread 编译选项。例如： ``` g++ -std=c++11 -pthread a.cpp <li>QT Creator 编译带&ltthread&gt的CPP有ＢＵＧ，暂时不知道怎么去除！ #### 代码1 ```#include <iostream> #i...
Linux/C++多线程编程学习笔记——线程同步、锁
mwz18959217316的博客
09-20 757
linux/C++线程同步机制，锁
常规说明：记录cpp知识点，面试题，网络编程，多线程编程
02-02
常规说明 :fire: C :heavy_plus_sign: :heavy_plus_sign: :sparkles: :sparkles: :eyes:最近在研究golang了，已经转到 ，喜欢...对Cpp Primer的学习笔记以及部分实现。以及研读有效的C ++ 55个项目 CSS 尝试读了一
CPP 多线程编程、互斥、同步 浅析
jojozym的博客
04-24 382
https://www.cnblogs.com/lidabo/archive/2012/08/15/2640204.html https://blog.csdn.net/QIANGWEIYUAN/article/details/88792621 本文主要是C++ 11中的多线程编程学习笔记。阅读时间大约15分钟。 C++ 11中创建线程非常简单，使用std::thread类就可以，thread...
C++多线程学习笔记1
09-04
最后，线程安全的容器和算法（如`std::atomic`、`std::queue`等）以及智能指针（`std::shared_ptr`、`std::unique_ptr`）在多线程编程中也扮演着重要角色，它们能帮助开发者编写出更加健壮的多线程代码。 本笔记的...
VC学习笔记之四：多线程知识.doc
09-08
- **复杂性增加**：多线程编程增加了软件设计的复杂性，特别是在处理线程间的同步和通信时。 #### 4.3 创建线程 在VC++中，可以通过多种方式创建线程，其中一个常用的方法是使用`CreateThread`函数。 #### 4.3.1 ...
cpp多线程编程demo3
惜兰blog
07-03 219
cpp多线程编程demo3 future promise std::future对象可以和async，std::packaged_task，std::promise一起使用。这篇文章集中讨论std::future和std::promise。 我们经常会遇到需要得到线程返回结果的情况，现在的问题是我们如何实现。 举个例子：假设在程序中，我们创建了一个压缩给定文件夹的线程，并且我们希望该线程能够返回新的zip文件的名称和大小。 有两种实现方式： 1、老方法：使用指针在线程间共享数据 传递一个指针到新的线程中，
Cpp标准库多线程编程
weixin_43572257的博客
07-10 508
更多使用 参考：https://en.cppreference.com/w/ thread类 //一个常用的构造函数形式 template< class Function, class... Args > explicit thread( Function&& f, Args&&... args );//参数均为右值引用，其为临时对象不会影响原来的对象 //线程的函数参数必须是一个没有返回值的函数 简单使用 #include <thread>//包含
CPP 多线程 实例
Talk Is Cheap
08-08 941
#include &lt;thread&gt; typedef void * HANDLER; void Func(HANDLER &amp; h){ //... } int main() { HANDLER h = InitModel(strModelPath); std::thread t1(Func,std::ref(h)); std::thread t2(Func...
【cpp】多线程管理：线程
突围
08-20 414
线程异常时，仍旧要先调用join 线程在异常时，会触发析构，析构时，会先调用std terminate， 因此发生异常，还是需要处理join或者detach掉这个线程，然后再让异常触发析构，否则terminate了，还没有join和detach是有问题的。 这是因为如果线程未退出，但是函数已经退出，线程可能还持有函数的局部变量。 单线程代码中，对象销毁之后再去访问，也会产生未定义行为 当在线程运行之后产生异常，在join()调用之前抛出，就意味着 这次调用会被跳过。 避免应用被抛出的异常所终止，就需要作.
cpp多线程编程demo1
惜兰blog
07-03 418
cpp多线程编程demo1 原作者 https://blog.csdn.net/lijinqi1987/category_5784833.html 创建线程 c++11线程库 原始的c++标准仅支持单线程编程，新的c++标准（c++11或c++0x）于2011年发布，引入了新的线程库。 编译器要求 Linux: gcc 4.8.1 (完全并发支持) Windows: Visual Studio 2012 and MingW 在linux下的编译方法： g++ -std=c++11 sample.cp
c/cpp - 多线程/进程 基础
L_fengzifei的博客
03-10 2366
c/cpp - 多线程/进程 基础
CPP并发与多线程（一）
qq_45741255的博客
08-17 787
1.线程启动、结束和创建 （1）函数创建 自己定义一个函数 void myPrint() { cout << "my subthread is starting" << endl; for (int i = 0; i < 5; i++) { cout << i << endl; } cout << "my subthread over" << endl; ​ retu
VC++多线程编程实战解析
通过十个实例深入解析多线程编程的奥秘，适合对多线程编程感兴趣的开发者学习。" 在VC++中，多线程编程是一种常见且实用的技术，它允许程序同时执行多个任务，提高了应用程序的效率和响应性。多线程在现代软件开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Rex久居

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值