AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

C++并发与多线程(四)async、future、packaged_task、promise、shared_future（下）

2023-08-05 93
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C++并发与多线程(四)async、future、packaged_task、promise、shared_future（下）

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

#include <iostream>
#include <future>
using namespace std;
int main(){
    cout << "main started and the thread id is " << std::this_thread::get_id() << endl;
    //我们把函数mythread通过packaged_task包装起来。参数是一个int，返回值类型是int
    std::packaged_task<int(int)> mypt([](int num){
        cout << "mythread() started and the thread id is " << std::this_thread::get_id() << endl;
        cout << "num is: " << num << endl;
        std::chrono::milliseconds dura(5000); // 休息五秒
        std::this_thread::sleep_for(dura);
        cout << "mythread() ended and the thread id is " << std::this_thread::get_id() << endl;
        return 5;
    });
    mypt(10);
    //std::thread mythread(std::ref(mypt), 10); // 线程直接开始执行，第二个参数为线程入口参数
    //mythread.join();
    //std::future对象里包含有线程入口函数的返回结果，这里result保存mythread返回的结果。
    std::future<int> res = mypt.get_future();
    cout << "res.get() is : " << res.get() << endl;
    cout << "main ended and the thread id is " << std::this_thread::get_id() << endl;
}

  还有一些加容器的骚操作：

#include <iostream>
#include <future>
#include <vector>
using namespace std;
vector<std::packaged_task<int(int)>> mytask;
int main(){
    cout << "main started and the thread id is " << std::this_thread::get_id() << endl;
    //我们把函数mythread通过packaged_task包装起来。参数是一个int，返回值类型是int
    std::packaged_task<int(int)> mypt([](int num){
        cout << "mythread() started and the thread id is " << std::this_thread::get_id() << endl;
        cout << "num is: " << num << endl;
        std::chrono::milliseconds dura(5000); // 休息五秒
        std::this_thread::sleep_for(dura);
        cout << "mythread() ended and the thread id is " << std::this_thread::get_id() << endl;
        return 5;
    });
    mytask.push_back(std::move(mypt)); // 入容器，用了移动语意。
    std::packaged_task<int(int)> mypt2;
    auto iter = mytask.begin();
    mypt2 = std::move(*iter); // 移动语意。
    mytask.erase(iter); // 删除第一个元素，后续代码已经不可以再使用iter了。
    mypt2(10);
    std::future<int> res = mypt2.get_future();
    cout << "res.get() is : " << res.get() << endl;
    cout << "main ended and the thread id is " << std::this_thread::get_id() << endl;
}

  程序输出结果为：

main started and the thread id is 0x1000e3d40
mythread() started and the thread id is 0x1000e3d40
num is: 10
mythread() ended and the thread id is 0x1000e3d40
res.get() is : 5
main ended and the thread id is 0x1000e3d40
Program ended with exit code: 0

std::promise

  std::promise，也是一个类模板，功能是：我们能够在某个线程中给它赋值，然后我们可以在其他线程中，把这个值取出来

#include <iostream>
#include <future>
#include <vector>
using namespace std;
void mythread(std::promise<int> &tmp, int calc){
    cout << "mythread() started and the thread id is " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000); // 休息五秒
    std::this_thread::sleep_for(dura);
    ++calc; // 假装有复杂的计算
    tmp.set_value(calc);
    cout << "mythread() ended and the thread id is " << std::this_thread::get_id() << endl;
}
int main(){
    cout << "main started and the thread id is " << std::this_thread::get_id() << endl;
    std::promise<int> myprom;
    std::thread t1(mythread, std::ref(myprom), 10);
    t1.join();
    std::future<int> res = myprom.get_future(); // future和promise绑定在一起。
    cout << "res.get() is : " << res.get() << endl;
    cout << "main ended and the thread id is " << std::this_thread::get_id() << endl;
}

  输出结果为：

main started and the thread id is 0x1000dfd40
mythread() started and the thread id is 0x16fe87000
mythread() ended and the thread id is 0x16fe87000
res.get() is : 11
main ended and the thread id is 0x1000dfd40
Program ended with exit code: 0
• 1
• 2
• 3
• 4
• 5
• 6

  总结：通过promise保存一个值，在将来某个时刻我们通过吧一个future绑定到这个promise上，来得到绑定的值。如果想把线程1中的值传入到线程2中去的话，可以采用如下方式：

#include <iostream>
#include <future>
#include <vector>
using namespace std;
void mythread(std::promise<int> &tmp, int calc){
    cout << "mythread() started and the thread id is " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000); // 休息五秒
    std::this_thread::sleep_for(dura);
    ++calc; // 假装有复杂的计算
    tmp.set_value(calc);
    cout << "mythread() ended and the thread id is " << std::this_thread::get_id() << endl;
}
void mythread_other(std::future<int> &tmp){
    cout << "mythread_other() started and the thread id is " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000); // 休息五秒
    std::this_thread::sleep_for(dura);
    cout << "mythread_other tmp.get() is : " << tmp.get() << endl;
    cout << "mythread_other() ended and the thread id is " << std::this_thread::get_id() << endl;
}
int main(){
    cout << "main started and the thread id is " << std::this_thread::get_id() << endl;
    std::promise<int> myprom;
    std::thread t1(mythread, std::ref(myprom), 10);
    t1.join();
    std::future<int> res = myprom.get_future(); // future和promise绑定在一起。
    std::thread t2(mythread_other, std::ref(res));
    t2.join();
    return 0;
}

  输出结果为：

main started and the thread id is 0x1000e7d40
mythread() started and the thread id is 0x16fe87000
mythread() ended and the thread id is 0x16fe87000
mythread_other() started and the thread id is 0x16fe87000
mythread_other tmp.get() is : 11
mythread_other() ended and the thread id is 0x16fe87000
Program ended with exit code: 0

std::future

  卡住当前流程，等待std::async()的异步任务运行一段时间，然后返回其状态std::future_status。如果std::async()的参数std::launch::deferred（延迟执行），则不会卡住主流程。std::future_status是枚举类型，表示异步任务的执行状态。类型的取值有：std::future_status::timeout，std::future_status::ready，std::future_status::deferred。

#include <iostream>
#include <future>
using namespace std;
int mythread() {
  cout << "mythread() started and the thread id is " << std::this_thread::get_id() << endl;
  std::chrono::milliseconds dura(5000); // 休息五秒
  std::this_thread::sleep_for(dura);
  cout << "mythread() ended and the thread id is " << std::this_thread::get_id() << endl;
  return 5;
}
int main() {
  cout << "main started and the thread id is " << std::this_thread::get_id() << endl;
  std::future<int> res = std::async(mythread); // 创建一个线程并开始执行
  cout << "continue ....." << endl;
  // std::future_status为枚举类型
  std::future_status status = res.wait_for(std::chrono::seconds(1)); // 等待1s钟
  if (status == std::future_status::timeout) { // 超时，表示线程还没有执行完，主线程等待1s钟，但是线程还没有执行完。
    cout << "超时，线程还没有执行完。" << endl;
  }
  else if (status == std::future_status::ready) {
    cout << "超时，线程成功执行完毕。" << endl;
    cout << res.get() << endl;
  }
  else if (status == std::future_status::deferred) {
    // std::future<int> res = std::async(std::launch::deferred, mythread); // 创建一个线程并延迟到get时执行
    cout << "超时，线程被延迟执行。" << endl;
    cout << res.get() << endl;
  }
  cout << "main ended and the thread id is " << std::this_thread::get_id() << endl;
}

  输出结果为：

std::shared_future

  get()只能使用一次，因为get()函数的设计是一个移动语义，相当于将result中的值移动到了复制对象中，再次get就报告了异常。如果有多个线程想要获得别的线程处理完的结果的话，shared_future就排上用场了。std::future的get()成员函数是转移数据。std::shared_future的get()成员函数是复制数据。

#include <thread>
#include <iostream>
#include <future>
using namespace std;
int mythread() {
  cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
  std::chrono::milliseconds dura(5000);
  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()> mypt(mythread);
  std::thread t1(std::ref(mypt));
  std::future<int> result = mypt.get_future();
  bool ifcanget = result.valid(); //判断future 中的值是不是一个有效值
  std::shared_future<int> result_s(result.share()); //执行完毕后result_s里有值，而result里空了
  //std::shared_future<int> result_s(std::move(result));
   //通过get_future返回值直接构造一个shared_future对象
   //std::shared_future<int> result_s(mypt.get_future());
   t1.join();
  auto myresult1 = result_s.get();
  auto myresult2 = result_s.get();
  cout << "good luck" << endl;
  return 0;
}

  或者通过通过get_future返回值直接构造一个shared_future对象：

#include <thread>
#include <iostream>
#include <future>
using namespace std;
int mythread() {
  cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
  std::chrono::milliseconds dura(5000);
  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()> mypt(mythread);
  std::thread t1(std::ref(mypt));
  t1.join();
  //std::future<int> result = mypt.get_future();
  //bool ifcanget = result.valid(); //判断future 中的值是不是一个有效值
  //std::shared_future<int> result_s(result.share()); //执行完毕后result_s里有值，而result里空了
  //std::shared_future<int> result_s(std::move(result));
   //通过get_future返回值直接构造一个shared_future对象
   std::shared_future<int> result_s(mypt.get_future());
  auto myresult1 = result_s.get();
  auto myresult2 = result_s.get();
  cout << "good luck" << endl;
  return 0;
}


文章标签：
C++
前端开发
容器
关键词：
C++多线程
C++线程
并发线程
C++并发
线程future
小小何先生
目录
相关文章
那年春天
|
1月前
|
前端开发 JavaScript 开发者
Async 和 Await 是基于 Promise 实现
【10月更文挑战第30天】Async和Await是基于Promise实现的语法糖，它们通过简洁的语法形式，借助Promise的异步处理机制，为JavaScript开发者提供了一种更优雅、更易于理解和维护的异步编程方式。
那年春天
27 1
mao29955
|
1月前
|
前端开发
如何使用async/await解决Promise的缺点？
总的来说，`async/await` 是对 Promise 的一种很好的补充和扩展，它为我们提供了更高效、更易读、更易维护的异步编程方式。通过合理地运用 `async/await`，我们可以更好地解决 Promise 的一些缺点，提升异步代码的质量和开发效率。
mao29955
35 5
mao29955
|
1月前
|
前端开发 JavaScript
async/await和Promise在性能上有什么区别？
性能优化是一个综合性的工作，除了考虑异步模式的选择外，还需要关注代码的优化、资源的合理利用等方面。
mao29955
38 4
最好zzz
|
1月前
|
缓存 安全 C++
C++无锁队列：解锁多线程编程新境界
【10月更文挑战第27天】
最好zzz
50 7
潇洒洒
|
1月前
|
消息中间件 存储 安全
深入探索C++无锁队列：多线程编程的高效利器
【10月更文挑战第19天】
潇洒洒
141 6
那年春天
|
1月前
|
JSON 前端开发 JavaScript
浅谈JavaScript中的Promise、Async和Await
【10月更文挑战第30天】Promise、Async和Await是JavaScript中强大的异步编程工具，它们各自具有独特的优势和适用场景，开发者可以根据具体的项目需求和代码风格选择合适的方式来处理异步操作，从而编写出更加高效、可读和易于维护的JavaScript代码。
那年春天
33 1
小王老师呀
|
2月前
|
存储 并行计算 安全
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛，常见场景包括并行计算、网络编程中的并发服务器和图形用户界面（GUI）应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计，以确保程序的正确性和稳定性。
小王老师呀
44 5
ephemerals__
|
26天前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
42 2
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
84 5
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
81 4