C++快速讲解（十）：线程

最新推荐文章于 2024-05-30 22:50:39 发布
最新推荐文章于 2024-05-30 22:50:39 发布
阅读量5.6k 收藏 105
点赞数 16
分类专栏： C++系列博客 文章标签： C++线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32306361/article/details/115268102
版权

C++快速讲解（十）：线程


前言：主要介绍了线程的创建、join和detach、线程传递参数、获取线程id、结束线程、并发访问、线程同步等。

1.创建线程

#include <iostream>
#include <thread>

using namespace std;
//创建线程

void show(){
    for (int i = 0; i < 10; ++i) {
        cout<<"---i:"<<i<<endl;
    }
}
int main() {
    thread t(show);
    cout<<"执行了main函数"<<endl;
    return 0;
}

在这里插入图片描述

2.join 和 detach

2.1 join

join 的意思是让主线程等待子线程执行结束后，在进行下一步，意思是让主线程挂起

#include <iostream>
#include <thread>
#include <windows.h>

using namespace std;

void show(){
    for (int i = 0; i < 10; ++i) {
        cout<<"i:"<<i<<endl;
        Sleep(500);
    }
}
int main() {
    //让这个线程执行上面的show 函数
    thread t(show) ;

    //让主线程等待子线程运行结束后，再继续下面的逻辑
    //否则主线程运行结束，程序就结束了。
    t.join();
    cout << "执行了main函数 " <<endl;
    return 0;
}

在这里插入图片描述

2.2 detach

detach的意思将本线程从调用线程中分离出来，允许本线程独立执行,从此和主线程再也没有任何关系。

#include <iostream>
#include <thread>
#include <windows.h>

using namespace std;

void show(){
    for (int i = 0; i < 10; ++i) {
        cout<<"i:"<<i<<endl;
        Sleep(500);
    }
}
int main() {
    thread t(show) ;
    t.detach();
    cout << "执行了main函数 " <<endl;
    return 0;
}

3.传递参数

往线程里面执行的函数传递参数，最长使用的办法就是bind机制 ， 这里以在线程内部构建学生对象，从外部传递姓名和年纪数据。

#include <iostream>
#include <thread>
#include <functional>

using namespace std;
//传递参数
class Student{
public:
    string name;
    int age;
    Student(string name,int age):name(name),age(age){
        cout <<"执行构造函数了~"  << name <<" = "<< age<< endl;
    }
};

void constructor(string name ,int age ){
    cout <<"执行构造学生的工作" << endl;
    Student s(name ,age);
}

int main() {
    thread t(bind(constructor,"fly",18));
    return 0;
}

在这里插入图片描述

4.获取线程id和休眠

  • 每一个线程在执行的时候，都有自己的一个标识id， 只有在少数情况下，线程的id会变得与众不同。通过 t.get_id() 获取线程对一个的id ， 也可以使用get_id() 获取当前线程的 id 。
  • 让线程休眠，等待一段时间然后继续执行，这样的场景在开发的时候经常会出现，在 c++中，让线程休眠，如果是在windows可以使用 windows.h头文件中的Sleep函数 ， 如果是linux 系统，可以使用#include里面的usleep函数 或者 也可以使用 this_thread:: 里面的 sleep_for 函数
#include <iostream>
#include <thread>
#include <windows.h>

using namespace std;
// 获取线程id
void show(){
    for (int i = 0;i<10;i++){
        Sleep(500);//休眠
        cout<<"i---->"<<i<<endl;
    }

}

int main() {
    cout <<"主线程的id："<< this_thread::get_id<< endl;
    thread t(show);
    cout<<"t.get_id():"<<t.get_id()<<endl;
    t.join();
    return 0;
}

在这里插入图片描述

5.结束线程

线程的退出，手段还是很多的，但是万般手段中，建议使用return。

#include <iostream>
#include <thread>
#include <functional>

using namespace std;

//结束线程
void show1(){
    for (int i = 0; i < 25; ++i) {
        if(i== 3){
            cout <<"函数返回，线程终止。" << endl;
            return ; //或者在这抛出异常，也形同return。
        }
    }
}

int main() {
    thread t(show1);
    return 0;
}

在这里插入图片描述

6.并发访问

由于cout对象并不会产生互斥，所以在多线程场景下，输出的结果并不是我们想要的，显得杂乱无章。这时候可以使用mutex 来控制互斥

#include <iostream>
#include <thread>
#include <windows.h>
#include <mutex>
using namespace std;
//并发访问

mutex mutext1;
void show(){
    int co = 10;
    while(co>0){
        mutext1.lock();//上锁
        cout<<"show_thread:"<<this_thread::get_id()<<endl;
        co--;
        mutext1.unlock();
        Sleep(500);
    }
}

int main() {
    thread t1(show);
    thread t2(show);
    t1.join();
    t2.join();
    return 0;
}

在这里插入图片描述

7.线程同步

如果有多个线程要同时访问一个变量或对象时，如果这些线程中既有读又有写操作 ， 或者同时写入 ，就会导致变量值或数据出现混乱，从而导致程序异常。

7.1 使用互斥量处理同步

#include <iostream>
#include <thread>
#include <functional>
#include <windows.h>
#include <mutex>
#include <queue>

using namespace std;
//线程同步 使用互斥量处理同步

class Box{};
//互斥变量
mutex mutex1;

//队列存放盒子
queue<Box*> q;
//初始化盒子
void init(){
    for (int i = 0; i < 10; ++i) {
        q.push(new Box());
    }
}

//从对列中取出盒子
void moveBox(string name){
    mutex1.lock();
    if(!q.empty()){
        Sleep(1000);
        q.pop();
        cout<<name<<"搬走了一个盒子现在还剩"<<q.size()<<endl;
    }
    mutex1.unlock();
}

void fun1(){
    while(1){
        moveBox("fun1");
        Sleep(1000);
    }
}

void fun2(){
    while(1){
        moveBox("fun2");
        Sleep(700);
    }
}

int main() {
    init();
    thread t1(fun1);
    thread t2(fun2);

    //阻塞主线程
    t1.join();
    t2.join();
    return 0;
}

在这里插入图片描述

7.2 lock_guard

一般来说不建议直接调用mutex 的成员函数lock 或者 unlock 来执行加锁解锁的操作，这要求程序员必须准确的知道在什么位置进行解锁操作。c++ 提供了一个模板类 lock_guard ，可以对mutex进行包装，在执行lock_guard的构造时进行加锁操作，执行lock_guard析构时进行解锁操作

#include <iostream>
#include <thread>
#include <mutex>
#include <windows.h>
using namespace std;

mutex mutex1;
void fun(){
    int count=10;
    while(count>0){
        //执行这句话，即上锁，等本次循环结束，会自动释放锁
        lock_guard<mutex> lg(mutex1);
        cout<<"fun的thread："<<this_thread::get_id()<<endl;
        cout<<"count："<< count<<endl;
        count--;
        Sleep(1000);
    }
}

int main(){
    thread t1(fun);
    thread t2(fun);
    t1.join();
    t2.join();
    return 0 ;
}

在这里插入图片描述

7.3 unique_guard

unique_guard 拥有 lock_guard的所有功能，并且内部还提供了加锁和解锁的操作，以便对加锁的粒度进行细化，而 lock_guard 的加锁范围通常是一个范围区域（比如函数） 。unique_lock 对于锁的管理比较灵活.它不像lock_guard 一样.必须要求他管理的锁在他初始化的时候必须加锁.而是可以自己灵活的.想加锁.就加锁.

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
#include <windows.h>
using namespace std;

mutex mutex1;

void fun(){
    int count=10;
    while(count>0){
        //执行这句话，即上锁，等本次循环结束，会自动释放锁
        unique_lock<mutex> ul(mutex1);
        cout<<"fun的thread："<<this_thread::get_id()<<endl;
        cout<<"count："<< count<<endl;
        count--;
        ul.unlock(); //可以手动释放锁
        Sleep(500);
    }
}

int main() {
    thread t1(fun);
    thread t2(fun);
    t1.join();
    t2.join();
    return 0;
}

在这里插入图片描述

7.4 条件变量

条件变量时从 condition_variable 直接翻译过来的，条件变量可以很好的管理多线程的并发操作。条件变量可以让线程达到某个条件的时候进入等待状态， 当条件变成对立面的时候线程继续执行。

7.4.1 简单使用

#include <iostream>
#include <deque>
#include <thread>
#include <mutex>
#include <windows.h>
#include <condition_variable>
using namespace std;

condition_variable cv;
mutex m;

void fun1(){
    for(int i = 1;i<100;i++){
        Sleep(1000);
        lock_guard<mutex> lk(m);
        cout << "func1 ----  i = " << i << endl;
        if(i%10 == 0){
            cout << "func1当前i能整除10 ，通知func1运行" << endl;
            cv.notify_one();
        }
    }
}

void fun2(){
    for(int i = 1;i<100;i++){
        unique_lock<mutex> ul(m);
        cout << "func2 ----  i = " << i << endl;
        if(i%5 == 0){
            cout << "func2当前i能整除5 ，通知func2运行" << endl;
            cv.wait(ul);
        }
    }
}


int main(){
    thread t2(fun2);
    thread t1(fun1);
    t1.join();
    t2.join();
    return 0 ;
}

在这里插入图片描述

7.4.2 条件变量实现搬运盒子

#include <iostream>
#include <thread>
#include <string>
#include <condition_variable>
#include <deque>
#include <windows.h>

using namespace std;

mutex m;
condition_variable cv;

class Box{};

//模拟工作台
deque <Box *> queue;

//左边的手臂把盒子搬上去
void leftMoveIn(){
    while(1){
        Box *box = new Box();
        queue.push_back(box);
        cout << "左手搬来一个，还剩：" << queue.size() << endl;
        cv.notify_all();
        Sleep(3000);
    }
}

void rightMoveOut(){
    while(1){
        unique_lock<mutex> ul(m);
        if(!queue.empty()){   //无限循环状态的轮询．
            queue.pop_back();
            cout << "右手搬走一个，还剩：" << queue.size() << endl;
            Sleep(1000);
        }else{
            //表示处于空的状态．等
            cout <<"没盒子了，右手等待"<<endl;
            cv.wait(ul);
        }
    }
}

//初始化盒子
void init(){
    for (int i = 0; i < 5; ++i) {
        queue.push_back(new Box);
    }
}

int main() {
    init();
    thread leftHand(leftMoveIn);
    thread rightHand(rightMoveOut);
    leftHand.join();
    rightHand.join();
    return 0;
}

在这里插入图片描述

7.5 async 函数

一般来说，函数如果在线程内部执行，当函数执行完毕后，想要获取到函数的返回值。除了在线程执行结束后，通过改变中间变量的方式之外，没有更好的办法了。 async 函数除了兼备thread的功能之外，还可以获取到函数的返回值。

7.5.1 简单使用

#include <iostream>
#include <future>


using namespace std;

int add(int a , int b){
    return  a + b;
}

int main() {
    //async背后会开启线程，用于运行add函数 <int> 表示函数的返回值类型
    future<int> future = async(add, 3, 4);

    //获取add函数的返回结果，get()会阻塞主线程，知道函数执行结束
    int result = future.get();

    cout << "result = " << result << endl;
    return 0;
}

7.5.2 启动策略

默认情况下，async函数背后不一定会执行创建新的线程执行函数，也有可能在当前线程上运行指定的函数。这是由于它的启动策略决定，可以通过函数的第一个参数指定。

//默认的启动策略
auto fut1 = std::async(f); // run f using default launch policy

//上面的代码等同于这一行。
auto fut2 = std::async(std::launch::async|std::launch::deferred,f);

7.5.3 异步操作

在async函数的第一个参数传递 launch::async 即可确保函数是异步执行

#include <iostream>
#include <future>
#include <unistd.h>

using namespace std;

void printI(){
    for (int i = 0; i < 10; ++i) {
        cout << "i == " << i << endl;
        usleep(1000 * 1000 * 1);
    }
}

int main() {
    //表示使用异步执行add函数
    async(launch::async ,printI );

}

7.5.4 同步操作

不管是否开启新的线程，只要调用了wait() 或者 get() 都会让函数运行，并且主线程陷入阻塞状态。wait()表示阻塞主线程，不会有结果被返回。get() 的底层显示调用了wait，接着获取到函数的结果。

#include <iostream>
#include <future>
#include <unistd.h>

using namespace std;

void printI(){
    for (int i = 0; i < 10; ++i) {
        cout << "i == " << i << endl;
        usleep(1000 * 1000 * 1);
    }
}

int main() {
    //表示使用异步执行add函数
    future<void> f = async(launch::async ,printI );
    f.get();
} 

//或者是：
int main() {
    //deferred: 表示延迟、推迟。 函数不会执行，除非后续调用get() 或  wait()
    future<void> f = async(launch::deferred ,printI );
    f.get();
    //f.wait();

    return 0 ;
}

结束！！！

等待着冬天的风
关注
  • 16
    点赞
  • 踩
  • 105
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++多线程详解（全网最全）
安徽锐锋科技-沐雨潇竹
04-22 1万+
传统的C++（C++11标准之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的，或者windows下的。C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。
C++11中多线程编程-std::async的深入讲解
12-16
C++11引入了std::async作为异步编程的一个高级接口，它简化了多线程编程，特别是对于那些需要在后台执行任务并等待结果的场景。std::async提供了灵活的线程创建策略，并且返回一个std::future对象，使得获取线程函数...
[C++]C++创建多线程的方法
FL1768317420的博客
02-28 1727
std::thread::detach() 方法是分离线程的方法，通过调用 detach() 方法，可以让线程在后台独立运行，不需要等待线程结束即可返回。与调用 join() 方法不同，分离的线程不受父线程的控制，因此如果父线程结束，分离的线程不会因此结束。需要注意的是，在这种情况下，还需要考虑线程间的同步和通信，以确保线程之间的数据一致性。第一个参数是一个指向线程 ID 的指针，第二个参数指定了线程的属性，通常为 NULL，第三个参数是线程函数的地址，最后一个参数是传递给线程函数的参数。
C++ 并发编程指南（5）线程状态及切换
最新发布
个人技术博客
05-30 1029
C++中的线程状态及切换是操作系统和C++线程库（如POSIX线程或C++11及之后的。
CreateThread
weixin_30487317的博客
03-26 236
CreateThread(NULL,0,ReportResultThread,this,0,&g_dwThreadId) 2. 参数说明： 第一个参数 lpThreadAttributes 表示线程内核对象的安全属性，一般传入NULL表示使用默认设置。 第二个参数 dwStackSize 表示线程栈空间大小。传入0表示使用默认大小（1MB）。 第三个...
C++多线程讲解
顺其自然~专栏
06-02 6359
线程：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，进程包含一个或者多个线程。进程可以理解为完成一件事的完整解决方案，而线程可以理解为这个解决方案中的的一个步骤，可能这个解决方案就这只有一个步骤，也可能这个解决方案有多个步骤。 多线程：多线程是实现并发（并行）的手段，并发（并行）即多个线程同时执行，一般而言，多线程就是把执行一件事情的完整步骤拆分为多个子步骤，然后使得这多个步骤同时执行。 C++多线程：（简单情况下）C++多线程使用多个函数实现各自功能，然后将不同函数生成不同线程，并同时执行
C++多线程图文详解
几度春风里的博客
03-14 9544
本文通过图文的形式详细介绍了C++多线程的thread、mutex、future、atomic、线程池，帮助多线程的理解。
C++多线程
钟离默的个人博客
08-13 8362
一、多线程简介 C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是<atomic> ，<thread>，<mutex>，<condition_variable>和<future>。 <atomic> ：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。 <thread>：该头文件主要声明了 std::th
C++线程安全的单例模式讲解
12-31
需要用锁，来保证其线程安全性：原因：多个线程可能进入判断是否已经存在实例的if语句，从而non thread safety。 使用double-check来保证thread safety。但是如果处理大量数据时，该锁才成为严重的性能瓶颈。 1、...
c++多线程编程的十个例子
08-21
以下是对“C++多线程编程的十个例子”的详细讲解，这些例子将帮助你在Windows环境下深入理解和应用多线程。 1. **创建线程** C++11引入了`std::thread`库来创建和管理线程。例如，你可以通过传递函数或成员函数...
C++多线程详细讲解和代码实例.rar
04-06
1. 线程：线程是程序执行的最小单元，一个进程可以包含一个或多个线程。每个线程有自己的程序计数器、寄存器和栈，共享同一地址空间，这意味着线程间的通信更为高效，但也可能导致数据竞争问题。 2. 并发与并行：...
C++ 线程
Cdreamfly的博客
03-02 6463
thread 类 thread 表示单个执行线程。线程允许多个函数同时执行。 线程在构造关联的线程对象时立即开始执行（等待任何OS调度延迟），从提供给作为构造函数参数的顶层函数开始。顶层函数的返回值将被忽略，而且若它以抛异常终止，则调用 std::terminate 。顶层函数可以通过 std::promise 或通过修改共享变量（可能需要同步，见 std::mutex 与 std::atomic ）将其返回值或异常传递给调用方。 std::thread 对象也可能处于不表示任何线程的状态（默认构造、被移动
一文详解C++多线程
热门推荐
非晚非晚的博客
04-25 7万+
传统的C++（C++11之前）中并没有引入线程这个概念，在C++11出来之前，如果我们想要在C++中实现多线程，需要借助操作系统平台提供的API，比如Linux的<pthread.h>，或者windows下的<windows.h> 。C++11提供了语言层面上的多线程，包含在头文件<thread>中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示：
C++中的线程、多线程
weixin_42258743的博客
09-27 963
C++ 多线程 多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。一般情况下，两种类型的多任务处理：基于进程和基于线程。 基于进程的多任务处理是程序的并发执行。基于线程的多任务处理是同一程序的片段的并发执行。多线程程序包含可以同时运行的两个或多个部分。这样的程序中的每个部分称为一个线程，每个线程定义了一个单独的执行路径。 .进程和线程的区别？ 线程分为用户级线程和内核支持线程两类，用户级线程不依赖于内核，该类线程的创建、撤销和切换都不利用系统调用来实现；内核支持线程依赖于内
C++ 并行编程(thread)---多线程
泠山的博客
10-31 1万+
进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。是程序执行的最小单位。
c++ 线程使用详解 创建线程的多种方法
luohaha66的博客
11-03 1496
函数原型： f：任何可调用对象。 args：传递给 f 的参数 构造新对象并将它与执行线程关联。
C++多线程编程深度解析
xueyukun1的博客
03-16 4219
线程是轻量级的进程，一个进程中的线程共享地址空间，全局变量、全局内存、全局引用都可以在线程之间传递，所以多线程的开销远远小于多进程
c++线程
05-24
C++ 线程是 C++11 标准中引入的一种多线程编程方式，它允许程序员创建并发执行的线程。C++ 线程库提供了一组类和函数，可以在多线程环境中创建、管理和同步线程。 以下是使用 C++ 线程的基本步骤： 1. 包含头文件 `#include<thread>` 2. 创建一个线程对象，指定要执行的函数或函数对象作为参数，如： ``` void myFunction(int arg1, double arg2); std::thread myThread(myFunction, 42, 3.14); ``` 3. 启动线程，使用 `myThread.join()` 或 `myThread.detach()` 函数，前者会等待线程执行完成后再继续执行主线程，后者则将线程分离，使其在后台执行，主线程不再控制它。 4. 在线程中执行代码，如： ``` void myFunction(int arg1, double arg2) { // 执行代码 } ``` 5. 等待线程执行结束，或者在主线程中使用条件变量等机制进行同步。 C++ 线程库还提供了一些其他的类和函数，如互斥锁、条件变量、原子操作等，可以帮助实现线程间的同步和通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

等待着冬天的风

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

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

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

打赏作者

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

抵扣说明：

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

余额充值