C++语法｜关于C++11线程类的线程回收技术：thread线程函数传参问题、std::ref、std::future、std::promise、std::packaged_task

已于 2024-05-29 21:34:10 修改
阅读量1.2k 收藏 15
点赞数 29
分类专栏： # C/C++ 文章标签： c++ java jvm
于 2024-05-29 21:25:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caiziming_001/article/details/139305437
版权

在C++11中，虽然库中的std::thread没有直接类似于pthread_join()的功能来获取子线程的返回数据，但可以通过几种方式实现相似的功能，主要是使用std::future和std::promise，或者std::async来从子线程获取数据。

文章目录

thread线程函数传参问题

我们当然也可以利用全局变量区、堆区来回收子线程返回的数据，但是我们首先需要解决 thread线程函数传参的问题。

#include <iostream>
#include <thread>

void handler1(int b)  // 此处形参b，接收t1实参a的值，正确！！！
{
    std::cout << "do handler1" << std::endl;
}
void handler2(int &b)  // 此处形参b，想引用实参a，语法错误！！！为什么？？？
{
    std::cout << "do handler2" << std::endl;
}
int main()
{
    int a = 10;
    std::thread t1(handler1, a);
    t1.join();

    // std::thread t2(handler2, a);   这里编译错误！！！
    // t2.join();
}

如果线程函数非得用int &b这样的左值引用来接收，我们必须这样传参：

    std::thread t2(handler2, std::ref(a));  //  注意这里使用std::ref(a)即可！！！
    t2.join();

这是为什么呢？

如果有兴趣，可以去看施磊老师的文章：C++ thread线程函数传参原理剖析
也就是说 handler的形参必须和传入参数的类型匹配！
handler2的类型是 void(*)(int&)，a的类型是int;
也就是说实参a传递的是右值，不能被一个左值引用int &b来接收！！
所以我们只要改成 void handler(int &&data)或者void handler(const int &data)都是可以解决问题的

为什么调用std::ref(data)就可以了？

我们首先需要明确一个概念：引用包装器。

它重载了很多操作符（比如解引用和函数调用），使其可以像原始引用那样使用。因此，在许多情况下，你可以用它来替代真正的引用，尤其是在API仅支持值传递的情况下。

也就是说虽然 data 在传参时是值传递 int 类型，但是经过引用包装器后，它会被强转为类型 int &data。

具体的我也是模棱两可，建议直接去看文章：
C++ thread线程函数传参原理剖析

std::future

std::future 是 C++11 引入的标准库类模板，用于表示异步操作的结果。它提供了一种机制，使一个线程可以等待另一个线程完成某项任务，并获取该任务的结果。std::future 与 std::promise、std::async、std::packaged_task 等类模板和函数一起，构成了 C++11 的异步编程模型。

std::future 的核心概念

  • 异步结果：std::future 持有一个异步操作的结果，当异步操作完成后，可以通过 std::future 获取结果。
  • 同步等待：std::future 提供了 get() 方法，该方法会阻塞调用线程，直到异步操作完成并返回结果。
  • 状态共享：std::future 和 std::promise 共享状态，std::promise 设置结果，std::future 获取结果。

std::future 的常用方法

  • get()：阻塞当前线程，直到异步操作完成，并返回结果。如果 std::promise 设置了异常，则 get() 会抛出该异常。
  • wait()：阻塞当前线程，直到异步操作完成。
  • wait_for(Duration d)：等待指定的时间段，直到异步操作完成或超时。
  • wait_until(TimePoint t)：等待直到指定的时间点，直到异步操作完成或超时。

std::promise 和 std::future

std::promise 是一个模板类，它允许你在一个线程中设置一个值，该值可以通过与之关联的 std::future 对象在另一个线程中获取。std::promise 提供了一种机制，使得你可以在异步任务完成时通知等待的线程，并传递结果或异常。

常用方法

  • set_value(T value)：设置 std::promise 对象持有的值。
  • set_exception(std::exception_ptr p)：设置 std::promise 对象持有的异常。
  • get_future()：获取与 std::promise 关联的 std::future 对象。

示例一

使用 std::promise 和 std::future 在两个线程之间传递一个整数结果：

#include <iostream>
#include <thread>
#include <future>

// 子线程函数
void func1(std::promise<int> promise) {
    int result = 42;  // 子线程计算的结果
    promise.set_value(result);  // 将结果传回主线程
}

int main() {
    // 创建一个 promise 对象
    std::promise<int> promise;

    // 获取与 promise 关联的 future 对象
    std::future<int> future = promise.get_future();

    // 创建并启动子线程
    std::thread t(func1, std::move(promise));

    // 从 future 对象中获取子线程的返回值
    int result = future.get();

    // 等待子线程结束
    t.join();

    // 输出子线程传回的结果
    std::cout << "Result from thread: " << result << std::endl;

    return 0;
}
  • std::promise<int> 创建一个 promise 对象，用于设置子线程的返回值。
  • promise.get_future() 返回一个与 promise 关联的 future 对象，用于获取子线程的返回值。
  • std::thread 创建并启动子线程，传递 promise 对象。
  • future.get() 获取子线程的返回值，主线程会阻塞在这里直到子线程设置了值。
  • t.join() 等待子线程结束。

示例二

std::promise 还可以用于在线程之间传递异常：

#include <iostream>
#include <thread>
#include <future>
#include <stdexcept>

// 子线程函数
void promiseTask(std::promise<int> promise) {
    try {
        throw std::runtime_error("An error occurred");  // 抛出异常
    } catch (...) {
        promise.set_exception(std::current_exception());  // 捕获并设置异常
    }
}

int main() {
    // 创建一个 promise 对象
    std::promise<int> promise;

    // 获取与 promise 关联的 future 对象
    std::future<int> result = promise.get_future();

    // 创建并启动子线程
    std::thread t(promiseTask, std::move(promise));

    try {
        // 获取异步任务的结果（如果有异常，将在这里抛出）
        int value = result.get();
        std::cout << "Result: " << value << std::endl;
    } catch (const std::exception& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }

    // 等待子线程结束
    t.join();

    return 0;
}
  • 子线程抛出一个异常并捕获，然后调用 promise.set_exception 将异常传递给 promise 对象。
  • 主线程调用 result.get()，如果 promise 设置了异常，get() 将抛出该异常。

std::packaged_task 和 std::future

std::packaged_task 是一个模板类，用于包装可调用对象（例如函数、lambda 表达式或函数对象），并允许将其结果传递给 std::future 对象。std::packaged_task 提供了一种方式来启动一个任务，并在任务完成后通过 std::future 获取其结果。

基本用法

  1. 创建一个 std::packaged_task 对象，包装一个可调用对象。
  2. 获取与 std::packaged_task 关联的 std::future 对象。
  3. 将 std::packaged_task 对象传递给一个线程以执行任务。
  4. 使用 std::future 对象获取任务的结果。
#include <iostream>
#include <thread>
#include <future>
#include <functional>

// 子线程函数
int func1(int x) {
    return x * 2;  // 计算结果
}

int main() {
    // 创建一个 packaged_task 对象，并将子线程函数包装进去
    std::packaged_task<int(int)> task(func1);

    // 获取与 task 关联的 future 对象
    std::future<int> result = task.get_future();

    // 创建并启动子线程，传递 packaged_task 对象和参数
    std::thread t(std::move(task), 5);

    // 等待任务完成并获取结果
    std::cout << "Result: " << result.get() << std::endl;

    // 等待子线程结束
    t.join();

    return 0;
}
  • std::packaged_task<int(int)> task(func1) 创建一个 packaged_task 对象，包装 func1 函数，它接受一个整数参数并返回一个整数。
  • task.get_future() 获取与 task 关联的 future 对象，用于获取任务的结果。
  • std::thread t(std::move(task), 5) 创建并启动子线程，执行 task（即 func1）并传递参数 5。
  • result.get() 获取子线程的返回值，输出结果。

lambda表达式作为子线程函数

#include <iostream>
#include <thread>
#include <future>

int main() {
    // 创建一个 packaged_task 对象，并将 lambda 表达式包装进去
    std::packaged_task<int(int, int)> task([](int a, int b) {
        return a + b;
    });

    // 获取与 task 关联的 future 对象
    std::future<int> result = task.get_future();

    // 创建并启动子线程，传递 packaged_task 对象和参数
    std::thread t(std::move(task), 3, 7);

    // 等待任务完成并获取结果
    std::cout << "Result: " << result.get() << std::endl;

    // 等待子线程结束
    t.join();

    return 0;
}
  • std::packaged_task<int(int, int)> task([](int a, int b) { return a + b; }) 创建一个 packaged_task 对象，包装一个 lambda 表达式，该表达式接受两个整数参数并返回它们的和。
  • task.get_future() 获取与 task 关联的 future 对象。
  • std::thread t(std::move(task), 3, 7) 创建并启动子线程，执行 task（即 lambda 表达式）并传递参数 3 和 7。
  • result.get() 获取子线程的返回值，输出结果。

成员函数作为子线程函数

#include <iostream>
#include <thread>
#include <future>

class MyClass {
public:
    int multiply(int a, int b) {
        return a * b;
    }
};

int main() {
    MyClass myObject;

    // 使用 std::bind 将成员函数包装为普通函数
    auto boundFunction = std::bind(&MyClass::multiply, &myObject, std::placeholders::_1, std::placeholders::_2);

    // 创建一个 packaged_task 对象，并将成员函数包装进去
    std::packaged_task<int(int, int)> task(boundFunction);

    // 获取与 task 关联的 future 对象
    std::future<int> result = task.get_future();

    // 创建并启动子线程，传递 packaged_task 对象和参数
    std::thread t(std::move(task), 4, 5);

    // 等待任务完成并获取结果
    std::cout << "Result: " << result.get() << std::endl;

    // 等待子线程结束
    t.join();

    return 0;
}
  • std::bind 将 MyClass 的成员函数 multiply 绑定到对象 myObject，并创建一个普通函数 boundFunction。
  • std::packaged_task<int(int, int)> task(boundFunction) 创建一个 packaged_task 对象，包装 boundFunction。
  • task.get_future() 获取与 task 关联的 future 对象。
  • std::thread t(std::move(task), 4, 5) 创建并启动子线程，执行 task（即成员函数）并传递参数 4 和 5。
  • result.get() 获取子线程的返回值，输出结果。

⭐️std::async 和 std::future

std::async 提供了一个比std::promise和std::package_task更简洁的方式来启动异步任务，并返回一个 std::future 对象，用于获取任务的结果。

std::async 的行为取决于其第一个参数 std::launch 的值，该值可以是 std::launch::async、std::launch::deferred 或二者的组合。下面详细解释 std::async 的工作原理及其选项。

工作原理

std::async 可以以两种方式执行任务：

  1. std::launch::async：强制在新线程中异步执行任务。
  2. std::launch::deferred：任务在调用 future.get() 或 future.wait() 时延迟执行，不会创建新线程。
  3. std::launch::async | std::launch::deferred（默认行为）：运行时决定是创建新线程执行任务还是延迟执行任务。

使用 std::launch::async

#include <iostream>
#include <future>

int asyncTask(int x) {
    return x * 2;
}

int main() {
    // 启动异步任务
    std::future<int> result = std::async(std::launch::async, asyncTask, 10);

    // 获取异步任务的结果
    std::cout << "Result: " << result.get() << std::endl;

    return 0;
}

在这个示例中，std::async(std::launch::async, asyncTask, 10) 强制在新线程中异步执行 asyncTask 函数，并返回一个 std::future<int> 对象。

使用 std::launch::deferred

#include <iostream>
#include <future>

int asyncTask(int x) {
    return x * 2;
}

int main() {
    // 使用 std::launch::deferred 延迟执行任务
    std::future<int> result = std::async(std::launch::deferred, asyncTask, 10);

    // 获取异步任务的结果（任务在此时才执行）
    std::cout << "Result: " << result.get() << std::endl;

    return 0;
}

std::async(std::launch::deferred, asyncTask, 10) 表示任务不会立即执行，而是在调用 future.get() 时才执行。

使用默认行为（std::launch::async | std::launch::deferred）

#include <iostream>
#include <future>

int asyncTask(int x) {
    return x * 2;
}

int main() {
    // 使用默认行为，由运行时决定执行策略
    std::future<int> result = std::async(asyncTask, 10);

    // 获取异步任务的结果
    std::cout << "Result: " << result.get() << std::endl;

    return 0;
}

在这个示例中，std::async(asyncTask, 10) 使用默认行为，由运行时决定是立即在新线程中执行任务还是延迟执行任务。

std::launch参数总结

  • std::launch::async：强制在新线程中执行任务。
  • std::launch::deferred：任务在调用 future.get() 或 future.wait() 时才执行，不创建新线程。
  • 默认行为（std::launch::async | std::launch::deferred）：运行时决定执行策略，可以是创建新线程执行任务，也可以是延迟执行。

因此，当使用 std::async 时，是否创建新线程取决于你传递的 std::launch 参数。如果明确指定 std::launch::async，那么 std::async 将创建一个新线程来处理任务。如果使用 std::launch::deferred，则任务将在调用 get 或 wait 时在调用线程中执行。如果使用默认行为，运行时将决定最适合的执行策略。

Che3rry
关注
  • 29
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
解析C++中std::ref
leapmotion的博客
09-16 9962
1. 前言 关于c++中的std::ref，std::ref在c++11引入。本文通过讲解std::ref的常用方式，及剖析下std::ref内部实现，进而再来讲解下std::reference_wrapper，然后我们再进一步分析为什么使用std::ref。 2. std::ref 用法 简单举例来说： int n1 = 0; auto n2 = std::ref(n1); n2++; n1++; std::cout << n1 << std::endl; // 2 std:
C++11 多线程学习
zw1996的博客
09-24 551
thread.hthread 类 （成员方法）thread 构造函数join 等待结束detach 分离线程,则无需等待结束this_thread 命名空间（静态方法）get_id 获取当前线程idyield 暂时交出cpu执行权sleep_for 睡眠等待函数sleep_until 等待到下一个具体的时间mutex.hmutex 互斥锁lock_guard 配合互斥锁，达到互斥锁作用域范围内的自动上锁解锁。
c++ ref在thread和bind中的使用
Peace
05-08 935
std::ref对std::thread std::mutex删除了拷贝构造函数。构造std::thread时，给线程函数传参时默认采用的是值传递(即使线程函数的入参为引用形式，这样设计应该时考虑到多个线程同时引用一个变量时的生命周期安全问题吧)， 所以被传参数对应的是含有mutex成员的类的实例时，编译不通过，需要使用std::ref。 #include <iostream> #include <thread> #include <mutex> #includ..
std::thread使用注意资源回收问题
xunye的博客
10-04 2045
一、线程 1、启动线程存在的固有开销 1. OS分配内核资源、堆栈空间 2. 将线程加入调度器 2、每个线程都需要一份独立的堆栈空间 对于32位系统，一个线程占用1MB的栈空间 3、线程间的任务调度，OS需要做上下文切换 因此，1. 线程启动后，需要关注其销毁 2. 系统资源有些，需要考虑启动线程的数量是否合适 二、thread使用问题 1、启动线程，主线程抛异常，异常退出 例子： #include <iostream> #include <thread> using namesp
C++ 多线程 std::promise
weixin_62953519的博客
10-26 258
最后，thread函数我们是用std::move函数将promise实例将其移动到testPromise函数中，因为promise是不可拷贝的类型，这个我们可以发现promise的拷贝构造函数是被delete了的，只能由移动构造函数进行传递，可能是因为future与promise有一个一对一的绑定关系，且是方案一对多或者多对多的；然后我们用一个相同模板类型的future类与promise绑定起来，这个是通过get_future函数做到的，这个时候future与promise实例进行了绑定；
C++11并发编程:多线程std::thread
08-26
C++11并发编程：多线程std::thread C++11引入了thread类，大大降低了多线程使用的复杂度。原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需...
c++11中关于std::thread的join的详解
08-26
C++11中关于std::thread的join详解 C++11引入了std::thread库，提供了对多线程编程的支持。std::thread库提供了两个基本操作：join和detach。join操作用于回收线程资源，避免资源泄露；detach操作用于将线程与创建...
C++11 并发指南之std::thread 详解
08-25
"C++11 并发指南之std::thread 详解" 本文主要介绍了 C++11 中的 std::thread 类...std::thread 类是 C++11 并发指南的重要组件，它提供了创建和管理线程的功能，允许开发者在程序中创建多个线程，从而实现并发编程。
C++ 11 std::function和std::bind使用详解
08-25
C++ 11 中引入了两个重要的功能：std::function 和 std::bind，它们都是基于 C++ 11 的新特性，用于实现函数指针的功能。下面将详细介绍这两个功能的使用和区别。 std::function 是一个可调用对象的包装器，用于...
C++11中std::future的具体使用方法
08-25
C++11中std::future的具体使用方法 std::future是一个模板类，提供了一种用于访问异步操作结果的机制。std::future所引用的共享状态不能与任何其它异步返回的对象共享。一个future是一个对象，它可以从某个提供者的...
82 C++线程资源的回收
wade1010的专栏
01-02 1140
1）在主程序中，调用join()成员函数等待子线程退出，回收它的资源。如果子线程已退出，join()函数立即返回，否则会阻塞等待，直到子线程退出。2）在主程序中，调用detach()成员函数分离子线程，子线程退出时，系统将自动回收资源。分离后的子线程不可join()。虽然同一个进程的多个线程共享进程的栈空间，但是，每个子线程在这个栈中拥有自己私有的栈空间。用joinable()成员函数可以判断子线程的分离状态，函数返回布尔类型。子线程的资源一定要回收，如果不回收，会产生僵尸线程，程序还会报错。
C++学习之路(01)—多线程std::thread初探
ROseeattimoo的博客
09-13 935
C++多线程初探
C++使用thread多线程基础【2】
W9XM96的博客
04-28 1540
C++多线程实现修改外部变量，以及获取函数返回值
C++ std::ref————详解
m0_51551385的博客
04-05 1万+
想学习ref，必须先学习reference_rapper 1、是什么？ ref是个函数模板： 用来构建一个reference_wrapper对象并返回，该对象拥有传入的elem变量的引用。如果参数本身是一个reference_wrapper类型的对象，则创建该对象的一个副本，并返回。 2、为什么要有ref std::ref主要在函数式编程（如std::bind）时使用，bind是对参数直接拷贝，无法传入引用（即使你传入的实参是引用类型也不行），故引入std::ref()。使用std::ref可以在模板传参
C++11——std::thread
没差的博客
09-15 1802
线程的创建——线程的启动与结束 通过函数来创建一个线程 #include <iostream> #include <thread> // 线程入口函数 void function() { std::cout << "The thread is start, thread_id = " << std::this_thread::get_i...
多线程c++实现（2）之向子线程中传数据（std::this_thread::get_id() 、 std::ref()）
请叫我少爷的博客
09-09 1834
上一个博客https://blog.csdn.net/shaochuang1/article/details/100302439介绍了创建多线程的几种方法，但是都是没有参数的那种，这篇博客我们来向子线程中传入参数。 #include <iostream> #include <thread> using namespace std; void Myprint(int...
C++ 并发编程之std::thread的基本用法
热门推荐
xiangxianghehe的博客
09-20 1万+
#include <iostream> #include <thread> using namespace std; void sayHello(); void show(); void method(int &a)//ref { a += 5; cout <<a<<endl; } int main(int argc, char const *argv[]) { int a =
c++在多线程std::thread中std::bind
最新发布
10-14
在多线程std::thread中使用std::bind可以将函数和参数绑定到一个可调用对象中，方便在多线程中使用。例如： ``` void foo(int a, int b) { // do something } int main() { std::thread t(std::bind(foo, 1, 2)); t.join(); return 0; } ``` 这里将函数foo和参数1、2绑定到了一个可调用对象中，然后在新线程中执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值