多线程之async、future、packaged_task、promise

// 多线程7.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <thread>
#include <list>
#include <mutex>
#include <future>
using namespace std;

class A
{
public:
	int mythread(int myvar)  //线程入口函数
	{
		cout << myvar<<endl;
		cout << "mythread() start" << "thread id =" << this_thread::get_id() << endl;  //打印线程id
		chrono::milliseconds dura(3000);
		this_thread::sleep_for(dura);     //休息3s
		cout << "mythread() end" << "thread id =" << this_thread::get_id() << endl;  //打印线程id
		return 5;
	} 

};
int mythread2(int myvar)  //线程入口函数
{
	cout << myvar << endl;
	cout << "mythread() start" << "thread id =" << this_thread::get_id() << endl;  //打印线程id
	chrono::milliseconds dura(3000);
	this_thread::sleep_for(dura);     //休息3s
	cout << "mythread() end" << "thread id =" << this_thread::get_id() << endl;  //打印线程id
	return 5;
}

void mythread3(std::promise<int> &temp, int calc)   //注意第一个参数
{
	//做一系列复杂的操作
	calc++;
	calc *= 10;
	//做其他运算,比如整整花费了3s钟
	chrono::milliseconds dura(3000);
	this_thread::sleep_for(dura);     //休息3s

	//终于计算出结果
	int result = calc;
	temp.set_value(result);  //结果保存到了temp这个对象中
	return;
}
void mythread4(future<int> &tempf)
{
	auto result = tempf.get();
	cout << "mythread4 resule=" << result << endl;
	return;
}
int main()
{
    //一:std::async、std::future创建后台任务并返回值
	//希望线程返回一个结果(除此之外,也可以通过全局变量、引用、指针等形式)
	//std::async是一个函数模板,用来启动一个异步任务,启动异步任务之后,返回一个std::future对象,std::future是个类模板
	//什么叫“启动一个异步任务”,就是自动创建一个线程并开始执行对应的线程入口函数,它返回一个future对象
	//这个future对象里边就含有线程入口函数所返回的结果(也称线程返回的结果),我们可以通过调用future对象的成员函数get()来获取结果
	//std::future提供了一种访问异步操作结果的机制,就是说这个结果可能没有办法马上拿到,但不久的将来(线程执行完毕的时候),才能拿到结果

	//可以通过额外向async()传递一个参数,该参数类型是launch类型(枚举类型),来达到一些特殊的目的:
	//a)std::launch::deferred: 表示线程入口函数调用被延迟到std::future对象的wait()或get()函数调用时才执行  (如果没有调用wait或get,则此线程不会被执行,实际上线程根本没被创建)
	//std::launch::deferred:延迟调用,并且没有创建新线程,是在主线程中调用的线程入口函数

	//b)std::launch::async:在调用async函数时就立即开始创建线程。
    //c)async的默认参数为:launch::async | launch::deferred,由系统自行决定调用方式(同步:不创建新线程还是异步:创建新线程)
	

	//下列程序通过future对象的get()成员函数等待线程执行结束并返回结果
	//A myobja;
	//int tempvar = 12;
	//cout << "main  " << "thread id =" << this_thread::get_id() << endl;
	//future <int> result = async(std::launch::async, &A::mythread,&myobja,tempvar);   //自动创建一个线程并开始执行对应的线程入口函数,返回一个future对象。流程不会卡在这里
	//cout << "continue.....!" << endl;
	//cout << "continue.....!" << endl;
	//cout << "continue.....!" << endl;
	//cout << "continue.....!" << endl;
	//cout << "continue.....!" << endl;
	//cout << "continue.....!" << endl;
	//cout << "continue.....!" << endl;
	//cout << result.get() << endl;   //卡在这里等待mythread()执行完毕,拿到结果。只能调用一次,调用多次会报异常
	result.wait();            //等待线程返回,本身不返回结果
	//cout << "主线程end" << endl;


	//二:std::packaged_task:打包任务,把任务包装起来
	//是个类模板,它的模板参数是各种可调用对象;通过std::packaged_task 来把各种可调用对象包装起来,方便将来作为线程入口函数来调用
	//packaged_task包装起来的可调用对象还可以直接调用,所以从这个角度讲,packaged_task对象是个可调用对象 (如在与线程入口函数包装完后,直接mypt(tempvar),但不会创建子线程,是在主线程中执行)

	//cout << "main  " << "thread id =" << this_thread::get_id() << endl;
	//packaged_task<int(int)> mypt(mythread2);   //把函数mythread2通过packaged_task包装起来
	/*
	//lambda表达式
	packaged_task<int(int)> mypt([](int myvar) {
		cout << myvar << endl;
		cout << "mythread() start" << "thread id =" << this_thread::get_id() << endl;  //打印线程id
		chrono::milliseconds dura(3000);
		this_thread::sleep_for(dura);     //休息3s
		cout << "mythread() end" << "thread id =" << this_thread::get_id() << endl;  //打印线程id
		return 5;
	});
	*/

	//int tempvar = 12;
	//thread t1(ref(mypt),tempvar);   //线程开始执行,tempvar为线程入口函数的参数
	//t1.join();  //等待线程执行完毕
	//future <int> result = mypt.get_future();   //future对象里包含有线程入口函数的返回结果,这里result保存mythread2返回结果
	//cout << result.get() << endl;
	//cout << "主线程end" << endl;


	//三:std::promise,类模板
	//我们能够在某个线程中给它赋值,然后我们可以再其他线程中,把这个值取出来
	//总结:通过promise保存一个值,在将来某个时刻通过一个future绑定到这个promise上来得到这个绑定的值
	promise <int> myprom; //声明一个promise对象myprom,保存值的类型为int
	int tempvar = 12;
	thread t1(mythread3, ref(myprom), tempvar);
	t1.join();  //用了thread对象,就必须用join来等

	//获取结果值
	future<int>ful = myprom.get_future(); //promise与future绑定
	//auto result = ful.get();   //get只能调用一次,不能调用多次
	//cout << "result = " << result << endl;

	//线程二获取结果
	thread t2(mythread4, ref(ful));
	t2.join();

	cout << "主线程end" << endl;


	//四:小结:到底怎么用,什么时候用
	//学习这些的目的,并不是要把它们都用在实际开发中
	//相反,如果能用最少的东西写出一个稳定高效的多线程程序,更值得赞赏

	return 0;
}

 

<think>好的,我现在需要详细系统地介绍C++中的std::async、std::packaged_task和std::promise多线程中的作用。首先,我得回忆一下这三个组件的基本概念和它们之间的区别。可能用户之前已经问过packaged_task的问题,现在希望更全面地了解这三个工具。 首先,std::async是用来异步执行函数的,它返回一个future对象,可以自动管理线程的创建和任务的执行。用户可能想知道它和其他两个的区别,比如是否自动启动线程,异常处理等。 接下来是std::packaged_task,它包装了一个可调用对象,允许将任务传递给其他线程,并通过future获取结果。之前已经详细讲过packaged_task,这里需要简要回顾,但重点放在与asyncpromise的对比上。 然后是std::promise,它允许显式设置值或异常,通常与future配对使用,用于更底层的结果传递。可能需要解释promise如何手动控制结果的设置,适合复杂场景。 接下来要考虑它们的共同点和不同点。三者都涉及futurepromise模式,但抽象层次不同。async更高级,自动管理线程;packaged_task是任务包装器,需要显式运行;promise是最底层的,需要手动设置结果。 需要分点详细说明每个组件的作用、使用场景、优缺点,可能还要比较它们的异同。比如,async适合简单的异步任务,而promise适用于需要从多个线程设置结果的情况,或者回调函数中传递结果。 另外,需要注意用户可能希望了解如何选择这三个工具,比如在什么情况下用哪个更合适。需要举一些例子,比如使用async快速执行任务,使用packaged_task将任务放入队列,使用promise处理线程间复杂的结果传递。 还要注意异常处理,三者如何处理异常,特别是promise需要显式设置异常,而asyncpackaged_task会自动捕获异常并传递到future。 可能还需要讨论线程管理,比如async的启动策略(deferred vs async),packaged_task需要手动移动到线程,promise可以在任何线程设置值。 最后,总结三者之间的关系和适用场景,帮助用户理解如何根据需求选择合适的工具。 现在需要组织这些内容,结构清晰,分点讲解每个组件,然后比较它们的异同,再给出使用建议和示例。确保使用正确的中文术语,避免技术术语错误,同时保持解释的准确性和易懂性。</think>以下是关于C++中`std::async`、`std::packaged_task`和`std::promise`的详细系统解析,重点阐述它们在多线程中的作用、差异及适用场景: --- ### 一、核心目标 三者均基于 **Future/Promise 模式**,实现 **异步计算** 与 **结果传递** 的解耦,但抽象层级和适用场景不同: | 组件 | 抽象层级 | 核心能力 | 适用场景 | |---------------------|------------|---------------------------|----------------------------| | `std::async` | 最高 | 自动管理线程和任务 | 快速启动简单异步任务 | | `std::packaged_task`| 中间 | 封装任务为可移动对象 | 需要显式控制任务调度的场景 | | `std::promise` | 最低 | 完全手动控制结果传递 | 复杂异步逻辑或跨线程协作 | --- ### 二、`std::async`:自动化异步任务 #### 1. 核心特性 - **一键启动**:通过函数调用直接启动异步任务。 - **自动线程管理**:根据策略(`std::launch::async`或`std::launch::deferred`)决定立即创建线程或延迟执行。 - **隐式结果绑定**:返回`std::future`自动绑定到异步结果。 #### 2. 代码示例 ```cpp #include <future> #include <iostream> int compute(int x) { return x * x; } int main() { auto future = std::async(std::launch::async, compute, 42); // 主线程可继续执行其他操作... std::cout << "Result: " << future.get() << std::endl; // 阻塞等待结果 } ``` #### 3. 关键行为 - **异常传递**:函数中的异常会通过`future.get()`抛出。 - **资源释放**:future析构时会隐式等待任务完成(若未分离线程)。 #### 4. 适用场景 - 快速执行不依赖线程资源的任务。 - 需要简洁代码实现异步计算。 --- ### 三、`std::packaged_task`:可移动的任务容器 #### 1. 核心特性 - **显式任务封装**:将函数/可调用对象包装为可移动对象。 - **手动调度控制**:需要显式传递任务到线程或线程池。 - **结果绑定**:通过`get_future()`获取关联的`std::future`。 #### 2. 代码示例 ```cpp #include <future> #include <thread> #include <queue> std::queue<std::packaged_task<int()>> task_queue; void worker() { while (!task_queue.empty()) { auto task = std::move(task_queue.front()); task_queue.pop(); task(); // 执行任务,结果自动存储到future } } int main() { std::packaged_task<int()> task([]{ return 42 * 42; }); auto future = task.get_future(); task_queue.push(std::move(task)); std::thread th(worker); th.detach(); std::cout << "Result: " << future.get() << std::endl; } ``` #### 3. 关键行为 - **资源所有权**:任务对象必须通过`std::move`传递。 - **延迟执行**:任务可存储在队列中,按需调度。 #### 4. 适用场景 - 需要将任务排队或批量提交到线程池。 - 需要灵活控制任务执行时机。 --- ### 四、`std::promise`:手动的结果传递通道 #### 1. 核心特性 - **完全手动控制**:通过`set_value()`/`set_exception()`显式传递结果。 - **多线程协作**:可在任意线程设置结果,与任务执行线程解耦。 - **多结果绑定**:一个`promise`可生成多个`future`(通过`shared_future`)。 #### 2. 代码示例 ```cpp #include <future> #include <thread> void compute(std::promise<int>&& prom) { try { int result = 42 * 42; prom.set_value(result); // 显式设置结果 } catch (...) { prom.set_exception(std::current_exception()); // 传递异常 } } int main() { std::promise<int> prom; auto future = prom.get_future(); std::thread th(compute, std::move(prom)); th.detach(); std::cout << "Result: " << future.get() << std::endl; } ``` #### 3. 关键行为 - **结果生命周期**:`promise`和`future`需保证结果传递期间的有效性。 - **灵活异常处理**:可手动捕获并传递异常。 #### 4. 适用场景 - 需要跨多个线程设置结果(如回调函数)。 - 需要实现自定义的异步通信协议。 --- ### 五、对比总结 | 特性 | `std::async` | `std::packaged_task` | `std::promise` | |---------------------|-------------------------|---------------------------|---------------------------| | **线程管理** | 自动 | 手动(需传递到线程) | 完全手动 | | **结果传递方式** | 隐式(自动绑定) | 半自动(任务执行后存储) | 显式(手动设置) | | **任务封装** | 直接绑定函数 | 封装为可移动对象 | 无封装,需手动关联 | | **灵活性** | 低 | 中 | 高 | | **典型场景** | 简单的一次性异步任务 | 任务队列/线程池调度 | 跨线程协作/复杂回调 | --- ### 六、选择指南 1. **优先使用`std::async`**: - 当任务简单且无需精细控制线程时。 - 示例:后台计算、文件读取等独立任务。 2. **选择`std::packaged_task`**: - 需要将任务存储到容器或跨线程传递时。 - 示例:线程池任务队列、批量任务调度。 3. **使用`std::promise`**: - 需要完全控制结果传递或跨多线程协作时。 - 示例:自定义事件循环、复杂回调链、多生产者单消费者模型。 --- ### 七、综合示例:混合使用三者 ```cpp #include <future> #include <thread> #include <vector> // 使用async快速启动任务 auto fetch_data() { return std::async([]{ return "Data from network"; }); } // 使用packaged_task管理任务队列 void process_data(std::packaged_task<std::string()> task) { task(); } // 使用promise处理回调 void save_to_db(const std::string& data, std::promise<bool> prom) { try { // 模拟数据库操作 prom.set_value(true); } catch (...) { prom.set_exception(std::current_exception()); } } int main() { // 1. async获取数据 auto data_future = fetch_data(); // 2. packaged_task处理数据 std::packaged_task<std::string()> process_task([&]{ return data_future.get() + " processed"; }); auto processed_future = process_task.get_future(); std::thread th1(std::move(process_task)); th1.join(); // 3. promise处理存储结果 std::promise<bool> save_prom; auto save_future = save_prom.get_future(); std::thread th2(save_to_db, processed_future.get(), std::move(save_prom)); th2.detach(); if (save_future.get()) { std::cout << "Complete!" << std::endl; } } ``` --- ### 八、关键注意事项 1. **线程安全**: - `promise`和`future`的非const方法非线程安全。 2. **生命周期管理**: - 确保`promise`对象在设置结果前有效。 3. **异常处理**: - 未处理的异常会导致`std::future_error`。 4. **性能考量**: - `std::async`默认策略可能延迟执行,需显式指定`std::launch::async`。 通过合理组合这三个工具,可以实现从简单到复杂的多线程异步编程需求。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值