55 C++ 多线程 返回值问题。引出的 async,future,packaged_task,promise.

已于 2024-01-20 20:52:18 修改
阅读量918 收藏 16
点赞数 23
文章标签： c++ 开发语言
于 2024-01-18 16:38:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hunandede/article/details/135672312
版权

一 前提，thread返回值的写法

在之前的代码中，我们并没有讨论 子线程的返回值问题。

这一章就考虑这个问题怎么处理。

下面我们先按照之前的写法，我们需要返回值时的可能的fix方案。

//如果线程有返回值，并且主线程要得到这个返回值，

//方案一：使用全局变量去接这个子线程的返回值。然后在main函数中取。


//如果线程有返回值，并且主线程要得到这个返回值，

//方案一：使用全局变量去接这个子线程的返回值。然后在main函数中取。
int teacher176readfuncreturnnumber = -1;
int teacher176writefuncreturnnumber = -1;

class Teacher176 {
public:
	mutex mymutex;
	list<int> mylist;

public:
	int readfunc(string &tempstr) {
		for (size_t i = 0; i < 10; i++)
		{
			mymutex.lock();
			cout << "read func tempstr = " << tempstr << "  i = " << i << " threadid = " << this_thread::get_id()<<  "  &tempstr = " << &tempstr <<  "  tempstr = " << tempstr << endl;
			mymutex.unlock();
		}
		int tempreturnvalue = 10;
		teacher176readfuncreturnnumber = tempreturnvalue;

		return tempreturnvalue;
	}

	int writefunc(double &tempdouble) {
		for (size_t i = 0; i < 10; i++)
		{
			mymutex.lock();
			cout << "write func tempdouble = " << tempdouble << "  i = " << i <<" threadid = " << this_thread::get_id() <<  "  &tempdouble = " << &tempdouble <<"   tempdouble = " << tempdouble << endl;
			mymutex.unlock();
		}
		tempdouble = tempdouble * 2;
		teacher176writefuncreturnnumber = (int)tempdouble;
		return (int)tempdouble;
	}
};

void main() {
	cout << "main thread start " << endl;
	Teacher176 tea;
	string name = "nihao";
	double dou = 60.8;
	cout << "main threadid = " << this_thread::get_id() << " &name = " << &name << "   name = " << name << "  dou = " << dou << "   &dou = " << &dou << endl;
	thread readthread(&Teacher176::readfunc,&tea, ref(name));//注意要第二个传递的 &tea,不会调用copy构造函数。注意第三个参数，如果不用ref包裹，那么传递的也是copy，即使readfunc的参数是引用，thread内部也会搞一个copy，且readfunc的参数必须是const的。
	thread writethread(&Teacher176::writefunc, &tea, ref(dou));
	readthread.join();
	writethread.join();

	cout << "teacher176readfuncreturnnumber = " << teacher176readfuncreturnnumber <<  "  teacher176writefuncreturnnumber = " << teacher176writefuncreturnnumber << endl;
	cout << "main thread end" << endl;
}

从上述代码中，虽然可以获得子线程的返回值，但是这样并不方便。

C++给考虑到这种case，提供了 async函数，返回值是 future的方案。

二 async函数模版，启动一个异步任务，返回值用 future 来接。

在标头 <future> 定义

2.1 async是干啥的？

async 是一个函数模版，用来启动一个异步任务。

注意这个异步任务可能是在子线程中启动，也可能不是在子线程中启动。这由 async的参数决定

//(C++11 起)(C++17 前)
//template< class Function, class... Args>
//std::future<std::result_of_t<std::decay_t<Function>(std::decay_t<Args>...)>> async(Function&& f, Args&&... args);

2.2 async的返回值future。从future中可以获得 异步任务的返回值

从C++文档上来看，返回值是个类对象-future，

std::future<std::result_of_t<std::decay_t<Function>(std::decay_t<Args>...)>> 

这个这个future里面有方法可以获得 返回值。

future中有用的成员函数

(构造函数)

构造 future 对象
(公开成员函数)

(析构函数)

析构 future 对象
(公开成员函数)

operator=

移动future对象
(公开成员函数)

share

从 *this 转移共享状态给 shared_future 并返回它
(公开成员函数)

获取结果

get

返回结果
(公开成员函数)

状态

valid

检查 future 是否拥有共享状态
(公开成员函数)

wait

等待结果变得可用
(公开成员函数)

wait_for

等待结果，如果在指定的超时间隔后仍然无法得到结果，则返回。
(公开成员函数)

wait_until

等待结果，如果在已经到达指定的时间点时仍然无法得到结果，则返回。
(公开成员函数)

2.3 async的返回值什么时候能拿到？--- 在异步任务执行完毕的时候

2.4 async方法参数详解

2.4.1 不带标志位。等同于 （ std::launch::async| std::launch::deferred ）

如下两行代码功能相同

    future<int> fu = async(std::launch::async | std::launch::deferred ,&Teacher177::readfunc, &tea, ref(name));
    future<int> fu = async(&Teacher177::readfunc, &tea, ref(name));

意思是：

会启动一个异步任务，这个异步任务有可能在子线程中发生，也有可能是在调用这段code的线程中发生(在当前code中是在主线程发生)。

那么为什么C++编译器要这么干呢？这是因为在创建一个thread的时候，有可能会创建thread失败，如果创建thread失败，系统直接就崩溃了。

但是如果是async，会根据当前系统的繁忙程度，决定到底要不要create 一个线程来完成这个异步任务。

class Teacher177 {
public:
	mutex mymutex;
	list<int> mylist;

public:
	int readfunc(string &tempstr) {
		for (size_t i = 0; i < 10; i++)
		{
			mymutex.lock();
			cout << "read func tempstr = " << tempstr << "  i = " << i << " threadid = " << this_thread::get_id() << "  &tempstr = " << &tempstr << "  tempstr = " << tempstr << endl;
			mymutex.unlock();
		}
		return 10;
	}

	int writefunc(const int &tempdouble) {
		for (size_t i = 0; i < 10; i++)
		{
			mymutex.lock();
			cout << "write func tempdouble = " << tempdouble << "  i = " << i << " threadid = " << this_thread::get_id() << "  &tempdouble = " << &tempdouble << "   tempdouble = " << tempdouble << endl;
			mymutex.unlock();
		}
		//tempdouble = tempdouble * 2;
		return (int)tempdouble;
	}

public:
	Teacher177() {
		cout << "Teacher177 构造方法被执行" << endl;
	}
	~Teacher177() {
		cout << "Teacher177 析构方法被执行" << endl;
	}
	Teacher177(const Teacher177& tea) {
		cout << "Teacher177 copy 构造 被执行" << endl;
	}
};

void main() {
	Teacher177 tea;
	string name = "nihao";
	int dou = 300;
	cout << "main threadid = " << this_thread::get_id() << " &name = " << &name << "   name = " << name << "  dou = " << dou << "   &dou = " << &dou << endl;

	future<int> fu = async(std::launch::async | std::launch::deferred ,&Teacher177::readfunc, &tea, ref(name));
	//future<int> fu = async(&Teacher177::readfunc, &tea, ref(name));

	future<int> fu1 = async(std::launch::async | std::launch::deferred ,&Teacher177::writefunc, &tea, dou);
	//future<int> fu1 = async(&Teacher177::writefunc, &tea, dou);

	cout<< fu.get() <<endl;
	cout<< fu1.get() <<endl;
	cout << "endsss" << endl;


	//Teacher177 构造方法被执行
	//	main threadid = 14384 & name = 000000EEBB73F778   name = nihao  dou = 300 & dou = 000000EEBB73F7B4
	//	read func tempstr = nihao  i = 0 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 1 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 2 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 3 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 4 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 5 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 6 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 7 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 8 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	read func tempstr = nihao  i = 9 threadid = 6124 & tempstr = 000000EEBB73F778  tempstr = nihao
	//	write func tempdouble = 300  i = 0 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	10
	//	write func tempdouble = 300  i = 1 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 2 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 3 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 4 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 5 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 6 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 7 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 8 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	write func tempdouble = 300  i = 9 threadid = 14380 & tempdouble = 00000201C9F947A8   tempdouble = 300
	//	300
	//	endsss
	//	Teacher177 析构方法被执行
}

2.4.2 带标志位  std::launch::async

    future<int> fu = async(std::launch::async ,&Teacher177::readfunc, &tea, ref(name));

如果您的业务逻辑一定要在子线程完成，那么请清晰的加上 std::launch::async 这个标识符，当然，如果系统很忙的时候，当执行到这一行代码的时候，也会create thread，也会崩溃。

2.4.3 带标志位  std::launch::deferred

future<int> fu = async(std::launch::deferred,&Teacher177::readfunc, &tea, ref(name));

如果是deferred，表示会延迟启动这个异步任务。

那么延迟到什么时候启动这个任务呢？--延迟到使用结果 fu.get()的时候，

而且通过代码实验，我们观察到，如果是deferred，不会在子线程启动异步任务，而是在 当前线程。

主线程threadid = 11008

其他两个异步任务的threadid也是11008

main threadid = 11008 &name = 0000003519CFF768   name = nihao  dou = 300   &dou = 0000003519CFF7A4
read func tempstr = nihao  i = 0 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 1 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 2 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 3 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 4 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 5 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 6 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 7 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 8 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
read func tempstr = nihao  i = 9 threadid = 11008  &tempstr = 0000003519CFF768  tempstr = nihao
10
write func tempdouble = 300  i = 0 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 1 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 2 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 3 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 4 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 5 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 6 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 7 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 8 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
write func tempdouble = 300  i = 9 threadid = 11008  &tempdouble = 0000020FD3DC41E8   tempdouble = 300
300
endsss
Teacher177 析构方法被执行

2.5 问题：async在不加参数的时候，由系统决定是 std::launch::deferred还是std::launch::async，那么这里有一个问题了，我们怎么知道系统这时候 是执行的那种呢？

 需要使用 wait_for参数，传递0，就可以马上知道

	//再没有参数(launch::async或者 launch::deferred)的情况下,我们怎么马上知道这行代码会使用那种模式运行呢？需要使用 wait_for参数，传递0
	promise<int> promi5;
	shared_future<double> fu9 = async(promisefunc181, ref(promi5), ref(str3));
	future_status fustatusfu9 = fu9.wait_for(chrono::seconds(0));
	if (future_status::deferred == fustatusfu9) {
		cout << "此行代码使用deferred模式运行" << endl;
		//如果这行代码一定要运行，在当前线程运行也可以那么这时候，你要使用get()方法让其运行
		fu9.get();
		//如果这行代码还必须要在子线程完成。那么就要写在子线程，这时候因为promi5已经用过了，就要重新弄一个promi6
		promise<int> promi6;
		async(launch::async,promisefunc181, ref(promi6), ref(str3));
	}
	else if(future_status::ready == fustatusfu9){
		cout << "此行代码使用async模式运行,且已经运行完毕,可以从future中get值了" << endl;
		double dou = fu9.get();
		cout << "douready = " << dou << endl;
	}
	else if (future_status::timeout == fustatusfu9) {
		cout << "此行代码使用async模式运行,但是超时了,可以调用 future中get中重新获得" << endl;
		double dou = fu9.get(); //调用 fu9.get()，去重新调用方法
		cout << "doutimeout = " << dou << endl;
	}

hunandede
关注
C++多线程--std::packaged_task
qls315的博客
07-09 613
本篇文章介绍 用于实现现代C++多线程中Task的另一个工具模版类：std::packaged_task.关于C++多线程实现Task的工具模版类，前面已经介绍了std::promise 和 std::future, 具体可参考C++多线程 task--std::promise和std::future_qls315的博客-CSDN博客std::packaged_task是一个模版类，其主要有如下几个功能std::packaged_task的函数声明如下所示 由上述模版声明可知，std::packaged
利用多线程，执行有返回值的方法
weixin_30546933的博客
08-18 570
解决的问题： 1. 当需要拿到多线程执行的方法的结果 2. 如何让主线程，等在所有的子线程直接结束 class Program { static void Main(string[] args) { IList<ManualResetEvent> listMan...
【C++学习】多线程
xsf_1903239203的博客
04-20 272
这篇文章中使用的是C++11之后的标准多线程库。
C++多线程获取返回值方法详解
08-19
主要介绍了C++多线程获取返回值方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
c++线程之 线程返回值、future、async
zzsxyl的博客
07-16 436
线程返回值、future、异步线async
第四课：C++带返回值线程处理函数
最新发布
qwers1235的博客
07-20 647
C++多线程；C++带返回值线程处理函数；
C++线程返回值
u013083044的博客
07-29 2888
C++线程返回值应用环境1、传统的方式获取线程返回值2、使用C++ Promise和future方式3、promise和future介绍 应用环境 通常主线程某些任务需要通过子线程完成数据处理之后才能继续执行；传统的方式就是主线程标志位给到子线程去，然后主线程这边采用循环等待的方式去等标志是否已经完成标示。另外一种方式就是使用c++11 promis 和future来完成 1、传统的方式获取线程返回值 代码如下： #include <iostream> #include &l
C++多线程学习（四、带返回值的线程处理函数）
多方通行8的博客
07-04 1094
2：通过get_future获取future对象，再通过get()方法获取线程处理函数中值【一旦通过get_future获取到future对象后，就不能再次调用get_future函数来获取新的future对象（除非你创建一个新的）】2.通过packaged_task的对象调用get_future获取future对象，再通过get()方法得到子线程处理函数的返回值。2.通过future对象中的get()方法获取线程函数的返回值。:启动一个异步的任务，创建线程并执行线程处理函数，
C++新特性（六）多线程（5）async、future、packaged_task、shared_future、promise
weixin_42445051的博客
02-17 983
一，async函数与future对象的使用 （顺便简单引入future) 1，async的普遍用法 std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，这个对象是个类模板。 什么叫“启动一个异步任务”？就是自动创建一个线程，并开始 执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象中就含有线程入口函数所返回的结果，我们可以通过调用future对象的成员函数get()来获取结果。下面给出一个使用例子
C++并发与多线程笔记八：async、future、packaged_task、promise
Rain_Mic的博客
04-09 658
本文接上文 C++并发与多线程笔记七：condition_variable、wait、notify_one/all 的内容，主要记录 async、future、packaged_task、promise 概念以及用法。
C++11获取线程返回值的实现代码
01-20
C++11 std::future and std::promise 在许多时候，我们会有这样的需求——即我们想要得到线程返回的值。 但是在C++11 多线程中我们注意到，std::thread对象会忽略顶层函数的返回值。 那问题来了，我们要怎么获得线程的返回值呢？ 我们通过一个例子来说明如何实现这个需求。 假设我们的app会创建一个线程来压缩一个文件夹，该线程在压缩完文件夹后会返回压缩文件 *.zip 和这个zip文件的大小，我们现在就想获得这个线程的返回值。 有两种方法可以实现这个需求： 1. 传统的方法：在线程间共享指针 传递一个指针给压缩文件的线程，表示压缩文件的线程将会把值写入指针指
C++11的future和promise、parkged_task使用
08-19
C++11的future和promise、packaged_task使用 C++11中引入了future、promise和packaged_task三个概念，用于实现异步编程和并发编程。这三个概念都是用于处理异步操作的结果，以下是它们的详细介绍： 一、future ...
C++11并发与多线程笔记（9） async、future、packaged_task、promise
qq_38231713的博客
05-13 4246
第九节、async、future、packaged_task、promise 本节内容需要包含头文件#include 一、std::async、std::future创建后台任务并返回值 std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，这个对象是个类模板。 什么叫“启动一个异步任务”？就是自动创建一个线程，并开始 执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象中就含有线程入口函数所返回
C++线程处理函数的返回值
肩上风骋的博客
09-17 1699
线程处理函数常见的返回类型为void，是否可以指定为其它类型的返回值呢。
C++多线程的线程返回值问题
君子以阅川的博客
09-18 2461
future对象，async函数，packaged_task函数，promise对象
C++多线程之带返回值的线程处理函数
m0_50597798的博客
09-05 933
创建带返回值的子线程
C++ thread学习四（使用async创建线程并返回结果）
mcc12356的博客
06-21 924
使用async创建一个新线程，返回一个future类型的对象，可以使用这种方法从线程中返回值。基本语法为： std::future<线程函数返回值类型> res = std::async(标记, 线程入口函数); 标记常用的有std::launch::deferred和std::launch::async。 std::launch::async：为系统默认缺省参数（如果不加标记，系统默认会加上这个），意思是为当执行此行语句时线程被创建并开始执行，但是如果此线程没有被执行完，会被阻塞在res
实例带你获取多线程Thread的返回值之(壹) - Callable的运行
_Adler.
03-15 233
前言 阅读本篇文章，你需要先理解以下知识： 多线程Thread的基本使用 （点我跳转） extends和implements 重写Override try catch错误处理 Java基础知识 回顾 回顾一下我们学过的Thread多线程，是继承了一个Thread类，然后调用run()方法来执行定义的类。 那么问题来了，有时候我们需要多线程传回一个计算的值给我们，Callable就很好地解决了我...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值