C++11并发与多线程笔记（9）async、future、packaged_task、promise

最新推荐文章于 2022-05-15 01:14:16 发布
最新推荐文章于 2022-05-15 01:14:16 发布
阅读量619 收藏 1
点赞数 1
分类专栏： C++多线程 文章标签： c++ 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/badmanwang/article/details/121175998
版权

文章目录

1、std::async、std::future创建后台任务并返回值

1.1 std::async

  • std::async是个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，他返回一个std::future对象，std::future是个类模板。
  • 启动一个异步任务：就是创建一个线程并开始执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象里面就含有线程入口函数所返回的结果，其实就是线程返回的结果，可以通过调用std::future对象的成员函数get()来获取结果。

1.2 std::future

  • std::async返回的对象，面就含有线程返回的结果。
  • future：将来的意思，有人也称呼std::future提供了一种访问异步操作结果的机制，就是说这个结果你可能没有办法马上拿到，但在线程执行完毕的时候，你就能拿到结果了，所以可以理解成：这个future里会保存一个值。

1.3 std::future::get()

  • std::future对象使用get()函数等待线程执行结束并返回结果，get()函数会一直卡在那里等待拿值，不拿到返回值，誓不罢休。
  • get()函数只能调用一次，不能调用多次，如果第二次get一个future对象会得到一个异常，主要是因为get函数的设计是一个移动语义，底层调用了std::move()。

1.4 std::future::wait()

  • 如果std::future对象使用wait()函数，则为等待线程返回，本身并不返回结果。
  • wait()函数可以调用多次，但除第一次调用wait()有效外，其余次均无效。

1.5 使用普通函数创建异步任务

示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <future>
using namespace std;

//线程入口函数
int mythread(int mypar)
{
    cout << mypar << endl;

    //打印新线程id值
    cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

    std::chrono::milliseconds dura(5000);		//休息5s
    std::this_thread::sleep_for(dura);
    cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
    return 5;
}

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	//创建一个线程并开始执行，将future对象和async创建的线程绑定到了一起，流程不卡到这里
	std::future<int> result = std::async(mythread);

	cout << "continue......!" << endl;
	int def;
	def = 0;

	//程序通过std::future对象的get()成员函数等待线程执行结束并返回结果
	//这个get()函数很牛，不拿到将来的返回值，誓不罢休，不拿导致就卡在这里等待拿值
	cout << result.get() << endl;
	//result.wait();
	cout << "I love China!" << endl;
	return 0;
}

1.6 使用类成员函数创建异步任务

示例代码：

#include <iostream>
#include <thread>
#include <mutex>
#include <future>
using namespace std;

class A
{
public:
	//线程入口函数
	int mythread(int mypar)
	{
		cout << mypar << endl;

		//打印新线程id值
		cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

		std::chrono::milliseconds dura(5000);		//休息5s
		std::this_thread::sleep_for(dura);
		cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
		return 5;
	}
};

int main()
{
	A a;
	int tmppar = 12;

	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	//创建一个线程并开始执行，将future对象和async创建的线程绑定到了一起，流程不卡到这里
	//第二个参数为对象引用，才能保证线程里用的是同一个对象
	std::future<int> result = std::async(&A::mythread, &a, tmppar);		

	cout << "continue......!" << endl;
	int def;
	def = 0;

	cout << result.get() << endl;
	//result.wait();
	cout << "I love China!" << endl;
	return 0;
}

1.7 std::lanuch

  • 我们通过额外向std::async()传递一个参数，该参数类型是std::lanuch类型（枚举类型），来达到一些特殊的目的。

1.7.1 std::lanuch::deferred

  • std::lanuch::deferred：表示线程入口函数调用被延迟到std::future的wait()或者get()函数调用时才执行；如果wait()或者get()没有被调用，那么线程就不会被执行，实际上，线程根本就没创建。

    #include <iostream>
#include <thread>
#include <mutex>
#include <future>
using namespace std;

class A
{
public:
	//线程入口函数
	int mythread(int mypar)
	{
		cout << mypar << endl;

		//打印新线程id值
		cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

		std::chrono::milliseconds dura(5000);		//休息5s
		std::this_thread::sleep_for(dura);
		cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
		return 5;
	}
};

int main()
{
	A a;
	int tmppar = 12;

	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	//创建一个线程并开始执行，将future对象和async创建的线程绑定到了一起，流程不卡到这里
	//第二个参数为对象引用，才能保证线程里用的是同一个对象
	std::future<int> result = std::async(std::launch::deferred,&A::mythread, &a, tmppar);
    //std::future<int> result = std::async(std::launch::async,&A::mythread, &a, tmppar);	
	cout << "continue......!" << endl;
	int def;
	def = 0;

	cout << result.get() << endl;
	//result.wait();
	cout << "I love China!" << endl;
	return 0;
}

    当get()函数没有被调用，代码执行结果如图：

    image-20211104193040851

    结果说明：如果wait()或者get()没有被调用，那么线程就不会被执行，实际上，线程根本就没创建。

  • 当调用了get()函数，代码执行结果如图：

    image-20211104193846447

    可以看到，子线程ID和主线程ID是一样的，说明当对async()使用std::launch::deferred参数时，根本没有创建子线程，自始至终都只有一个主线程，是在主线程中调用的线程入口函数。

1.7.2 std::lanuch::async

  • std::lanuch::async：表示在调用std::async()函数的时候就开始创建线程，强制创建一个线程。

2、std::packaged_task

  • std::packaged_task：是个类模板，它的模板参数是各种可调用对象；
  • 通过std::packaged_task把各种可调用对象包装起来，方便将来作为线程入口函数来调用。

std::packaged_task包装普通调用函数示例代码：

#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <future>
using namespace std;

//线程入口函数
int mythread(int mypar)
{
	cout << mypar << endl;

	//打印新线程id值
	cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

	std::chrono::milliseconds dura(5000);		//休息5s
	std::this_thread::sleep_for(dura);
	cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
	return 5;
}

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;
	std::packaged_task<int(int)> mypt(mythread);		//我们把函数mythread通过packaged_task包装起来
	std::thread t1(std::ref(mypt), 1);	//线程直接开始执行，第二个参数为线程入口函数的参数

	t1.join();		//等待线程执行完毕

	//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread函数返回的结果
	std::future<int> result = mypt.get_future();
	cout << result.get() << endl;

	cout << "I love China!" << endl;

	return 0;
}

std::packaged_task包装lambda表达式示例代码：

#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <future>
using namespace std;

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;

	std::packaged_task<int(int)> mypt([](int mypar)
		{
			cout << mypar << endl;

			//打印新线程id值
			cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

			std::chrono::milliseconds dura(5000);		//休息5s
			std::this_thread::sleep_for(dura);
			cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
			return 5;
		});

	std::thread t1(std::ref(mypt), 1);	//线程直接开始执行，第二个参数为线程入口函数的参数

	t1.join();		//等待线程执行完毕

	//std::future对象里包含有线程入口函数的返回结果，这里result保存mythread函数返回的结果
	std::future<int> result = mypt.get_future();
	cout << result.get() << endl;

	cout << "I love China!" << endl;

	return 0;
}

结果如下，子线程和主线程id不同：

image-20211104202428810

  • std::packaged_task包装起来的可调用对象还可以直接调用，从这个角度来讲，std::packaged_task对象也是一个可调用对象。

  • 如果直接调用std::packaged_task对象，相当于执行一个函数，就不会创建一个新的线程。

    示例代码：

    #include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <future>
using namespace std;

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;

	std::packaged_task<int(int)> mypt([](int mypar)
		{
			cout << mypar << endl;

			//打印新线程id值
			cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

			std::chrono::milliseconds dura(5000);		//休息5s
			std::this_thread::sleep_for(dura);
			cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
			return 5;
		});

	mypt(105);		//直接调用
	std::future<int> result = mypt.get_future();
	cout << result.get() << endl;

	cout << "I love China!" << endl;

	return 0;
}

    结果如下：

    image-20211104204248891

  • 使用容器对std::packaged_task对象进行存储并调用，要使用std::move()来移动对象，不然会消耗资源进行复制。

    代码如下：

    #include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <future>
using namespace std;

vector<std::packaged_task<int(int)>> mytasks;	//容器

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;

	std::packaged_task<int(int)> mypt([](int mypar)
		{
			cout << mypar << endl;

			//打印新线程id值
			cout << "mythread() start " << "threadid = " << std::this_thread::get_id() << endl;

			std::chrono::milliseconds dura(5000);		//休息5s
			std::this_thread::sleep_for(dura);
			cout << "mythread() end " << "threadid = " << std::this_thread::get_id() << endl;
			return 5;
		});

	mytasks.push_back(std::move(mypt));		//入容器，这里使用了移动语义，入进去之后mypt就为空
	std::packaged_task<int(int)> mypt2;
	auto iter = mytasks.begin();
	mypt2 = std::move(*iter);		//使用移动语义
	mytasks.erase(iter);		//删除第一个元素，迭代已经失效了，所以后续代码不可以再使用iter

	mypt2(123);
	std::future<int> result = mypt2.get_future();
	cout << result.get() << endl;

	cout << "I love China!" << endl;

	return 0;
}

    结果如下，同样不会创建新线程：

    image-20211104205414998

3、std::promise

  • std::promise：类模板。
  • 作用：能够在某个线程中给它赋值，然后可以在其他线程中，把这个值取出来用。

示例代码：

#include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <future>
using namespace std;

void mythread(std::promise<int>& tmpp, int calc)	//注意第一个参数写法
{
	cout << "mythread()id = " << std::this_thread::get_id() << endl;
	
	//这里做一系列复杂操作
	calc++;
	calc *= 10;
	//做其他运算，比如整整花费了5秒钟
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);

	//终于计算出结果了
	int result = calc;	//保存结果
	tmpp.set_value(result);		//结果保存到了tmpp这个对象中
	return;
}

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;

	std::promise<int> myprom;		//声明一个std::promise对象myprom，保存值类型为int
	std::thread t1(mythread, std::ref(myprom), 180);
	t1.join();

	//获取结果值
	std::future<int> fu1 = myprom.get_future();		//promise和future绑定，用于获取线程返回值
	auto result = fu1.get();		//get只能调用一次，不能调用多次

	cout << "result = " << result << endl;
	cout << "I love China!" << endl;

	return 0;
}

结果如下：

image-20211104211053440

  • 将一个线程的结果传递到另一个线程使用

    示例代码：

    #include <iostream>
#include <thread>
#include <vector>
#include <list>
#include <mutex>
#include <future>
using namespace std;

void mythread(std::promise<int>& tmpp, int calc)	//注意第一个参数写法
{
	cout << "mythread()id = " << std::this_thread::get_id() << endl;
	
	//这里做一系列复杂操作
	calc++;
	calc *= 10;
	//做其他运算，比如整整花费了5秒钟
	std::chrono::milliseconds dura(5000);
	std::this_thread::sleep_for(dura);

	//终于计算出结果了
	int result = calc;	//保存结果
	tmpp.set_value(result);		//结果保存到了tmpp这个对象中
	return;
}

void mythread2(std::future<int>& tmpf)
{
	cout << "mythread2()id = " << std::this_thread::get_id() << endl;

	auto result = tmpf.get();
	cout << "mythread2 result = " << result << endl;
	return;
}

int main()
{
	cout << "main " << "threadid = " << std::this_thread::get_id() << endl;

	std::promise<int> myprom;		//声明一个std::promise对象myprom，保存值类型为int
	std::thread t1(mythread, std::ref(myprom), 180);
	t1.join();

	//获取结果值
	std::future<int> fu1 = myprom.get_future();		//promise和future绑定，用于获取线程返回值

	std::thread t2(mythread2, std::ref(fu1));
	t2.join();		//等mythread2执行完毕
	cout << "I love China!" << endl;

	return 0;
}

    结果如下：

    image-20211104211809301

4、小结

  • 我们学习这些东西的目的，并不是要把他们都用在咱们自己的实际开发中。
  • 相反，如果我们能够用最少的东西能够写出一个稳定、高效的多线程程序，更值得赞赏。
  • 我们为了成长，必须要阅读一些高手写的代码，从而快速实现自己代码的积累，我们的技术就会有一个大幅度的提升。

注：本人学习c++多线程视频地址：C++多线程学习地址

Jack丶Wang
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ future/ promise/ packaged_task/ async
xiaolifeidaofirst的博客
09-15 183
c++并发
C++11 async
程序员Link
10-10 745
目录一 前面二 定义三 例子四 参考 一 前面 C++11开始，对并发提供了强有力的支持，本文介绍其中的 std::async。 头文件< future > 二 定义 template< class Function, class... Args> std::future<std::result_of_t<std::decay_t<Function>(std::decay_t<Args>...)>> async( Fun
C++11之future,promise,packaged_task,async详解
越努力越幸运—liupu
05-27 9592
C++11为了给我们提供更便利的并发编程，加入了 future，promise，packaged_task，async 这几个新特性，那么它们到底有什么作用又能给我们带来哪些便利呢？ 经典的生产-消费模型 mutex + condition_variable: 首先让我们来看一个最经典的生产-消费模型： #include #include #include #includ
C++async、future、packaged_task、promise的使用
dxgzg的博客
11-03 501
目录asyncfuturepackaged_task用法1 async 初学多线程的我天真的以为异步和多线程是一样的，直到我看见了std::async这个处理异步的函数（头文件在future里面），我才知道异步和多线程是不一样的。 关于多线程与异步区别生动形象的例子 为什么有了多线程还需要异步操作？身为初学的我想到了这个问题在网上百度了没百度到，好在今天读书的时候又找到了自己想要的答案了。首先要注意到开启一根多线程是不能保存返回值，那么聪明的你肯定也想到函数增加一个引用类型参数，不就解决了嘛，代码如下。这样
C++11 原生的多线程实例
zxcvb036的博客
05-08 163
from:https://en.cppreference.com/w/cpp/thread/async #include "stdafx.h" #include <iostream> #include <vector> #include <algorithm> #include <numeric> #include <future> #include <string> #include <mutex> std:
C++ 11 线程 promise、future、async、packaged_task
qq_24127015的博客
03-12 363
1.promise和future future和promise的作用是在不同线程之间传递数据。使用指针也可以完成数据的传递，但是指针非常危险，因为互斥量不能阻止指针的访问；而且指针的方式传递的数据是固定的，如果更改数据类型，那么还需要更改有关的接口，比较麻烦；promise支持泛型的操作，更加方便编程处理。 假设线程1需要线程2的数据，那么组合使用方式如下： 线程1初始化一个promise对...
多线程07：async、future、packaged_task、promise
pythonxxoo的博客
05-15 194
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 📕async、future、packaged_task、promise 本节内容需要包含头文件：#include 一、std::async、 std::future 创
c++多线程基础5(future，async，packaged_task，promise)
weixin_30462049的博客
03-13 149
以下内容整理自：https://www.cnblogs.com/my_life/articles/5401190.html future 是一个能从其他地方获取到一个值的对象，如果是在不同的线程中，则被synchronizing properly. std::condition_variable 可以用于异步事件的重复通知，但是有些时候可能只等待事件发生一次，比如：等待特定的航班，用条件变量大...
C++新特性（六）多线程（5）async、future、packaged_task、shared_future、promise
weixin_42445051的博客
02-17 740
一，async函数与future对象的使用 （顺便简单引入future) 1，async的普遍用法 std::async是一个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，它返回一个std::future对象，这个对象是个类模板。 什么叫“启动一个异步任务”？就是自动创建一个线程，并开始 执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象中就含有线程入口函数所返回的结果，我们可以通过调用future对象的成员函数get()来获取结果。下面给出一个使用例子
C++11之std::future以及async函数、promise类和packaged_task类结构图
03-18
C++11之std::future以及async函数、promise类和packaged_task类结构图
C++11的future和promise、parkged_task使用
12-20
它可以从异步的对象或者函数任务中获取结果，它通常和std::async、promise、packaged_task相互调用。 future对象通常是在valid有效的情况下可以使用，默认的构造函数是valid是false的，所以在使用future时，需要对其...
c++11多线程编程之std::async的介绍与实例
12-16
本节讨论下在C++11中怎样使用std::async来执行异步task。 C++11中引入了std::async 什么是std::async std::async()是一个接受回调(函数或函数对象)作为参数的函数模板，并有可能异步执行它们. template future...
C++11中多线程编程-std::async的深入讲解
12-16
C++11中提供了异步线程接口std::async，std::async是异步编程的高级封装，相对于直接使用std::thread，std::async的优势在于: 1、std::async会自动创建线程去调用线程函数，相对于低层次的std::thread，使用起来非常...
Async_task_ETTask_async_
10-04
这是ETTask中的Async部分，它是一个单线程的Task
future 线程报错后_C++并发与多线程学习笔记--async、future、packaged_task、promise
weixin_42476061的博客
01-12 184
asyncfuturepackaged_taskpromiseasyncstd:async是个函数，用来启动一个异步任务，启动起来一个异步任务之后，返回一个std::futre对象，启动一个异步任务，就是自动创建一个线程并开始执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象里面就含有线程入口函数返回的结果。可以通过调用future对象的成员函数get来...
C++ future async promise 用法详解 - packaged_task
weixin_40058501的博客
05-13 129
packaged_task 文章目录packaged_task背景原理基本函数基本用法 背景 启发于function pointer 采用类似 promise 的设计 方便的获取线程运行结果 原理 生产者 - 消费者模型 基本函数 生产函数，分两步 设置value或者exception 设置shared state // 设置value或者exception后，立即将shared state设置为ready void operator()(Args... args); // 设置value或
C++ 文件和文件流
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-22 358
C++ 文件和流 到目前为止，我们已经使用了 iostream 标准库，它提供了 cin 和 cout 方法分别用于从标准输入读取流和向标准输出写入流。 本教程介绍如何从文件读取流和向文件写入流。这就需要用到 C++ 中另一个标准库 fstream，它定义了三个新的数据类型： 数据类型描述 ofstream该数据类型表示输出文件流，用于创建文件并向文件写入信息。 ifstream该数据类型表示输入...
6-9 async、future、packaged_task、pro
昔拉的博客
07-03 218
一：std::async、std::future创建后台任务并返回值 希望线程返回一个结果； std::async是个函数模板，用来启动一个异步任务，启动起来一个异步任务之后，他返回一个std::future对象，std::future是个类模板。 什么叫”启动一个异步任务“，就是自动创建一个线程并开始执行对应的线程入口函数，它返回一个std::future对象，这个std::future对象里边就含有线程入口函数所返回的结果（线程返回的结果）；我们可以通过调用future对象的成员函数get()来获取。
C++11多线程编程 9.async、future、packaged_task、promise
guonengneng的博客
09-04 201
#include<iostream> #include<string> #include<thread> #include<asyncinfo.h> #include<future> #include<vector> using namespace std; class A { public: int mythread2(int mypar) { cout << mypar << ...
struct MdCtx { napi_env env = nullptr; CfAsyncType asyncType = ASYNC_TYPE_CALLBACK; napi_ref callback = nullptr; napi_deferred deferred = nullptr; napi_value promise = nullptr; napi_async_work asyncWork = nullptr; NapiMd *mdClass = nullptr; std::string algoName = ""; HcfBlob *inBlob = nullptr; HcfResult errCode = HCF_SUCCESS; const char *errMsg = nullptr; HcfBlob *outBlob = nullptr; }; context->asyncType = (argc == maxCount) ? ASYNC_TYPE_CALLBACK : ASYNC_TYPE_PROMISE; 代码解析
最新发布
06-03
- asyncType：CfAsyncType 类型，表示异步操作的类型，可以是 ASYNC_TYPE_CALLBACK 或 ASYNC_TYPE_PROMISE。 - callback：napi_ref 类型，表示异步操作完成后的回调函数。 - deferred：napi_deferred 类型，表示用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值