C++11异步编程
创始人
2024-06-01 14:29:59
0

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档

文章目录

  • 前言
  • 1、std::future和std::shared_future
    • 1.1 std:future
    • 1.2 std::shared_future
  • 2、std::async
  • 3、std::promise
  • 4、std::packaged_task

前言

C++11提供了异步操作相关的类,主要有std:future、std:promise 和std:package task。std:future作为异步结果的传输通道,可以很方便地获取线程函数的返回值;。std:promise 用来包装一个值、将数据和future绑定起来,方便线程赋值; std:package_task 用来包装一个可调用对象,将函数和future绑定起来,以便异步调用。

1、std::future和std::shared_future

1.1 std:future

C++11中增加的线程,使得我们可以非常方便地创建和使用线程,但有时会有些不便,比如希望获取线程函数的返回结果,就不能直接通过thread.join()得到结果,这时就必须定义一个变量,在线程函数中去给这个变量赋值,然后执行join(),最后得到结果,这个过程是比较烦琐的。thread 库提供了future用来访问异步操作的结果,因为一个异步操作的结果不能马上获取,只能在未来某个时候从某个地方获取,这个异步操作的结果是一个未来的期待值,所以被称为future,future 提供了获取异步操作结果的通道。我们可以以同步等待的方式来获取结果,可以通过查询future 的状态( future_status) 来获取异步操作的结果。futrue_status有3种状态:

1、Deferred:异步操作还没开始
2、Ready:异步操作已经完成
3、Timeout:异步操作超时

future原型

template   future;
template  future;     
template <>         future

std::future是一个类模板

成员方法
在这里插入图片描述
通过future构造函数构造的future对象是无效的,此时调用future.get()可能会抛异常,需要我们捕获

int main()
{future fu;try{cout << fu.get() << endl;}catch (const std::exception& e){cout << e.what() << endl;}return 0;
}

在这里插入图片描述

如果没有初始化future,则表明它是无效的,此时我们也可以使用valid判断future对象是否有效

int main()
{future fu;if (fu.valid()){fu.get();}else{cout << "no state" << endl;}return 0;
}

std::asyanc是std::future的高级封装, 一般我们不会直接使用std::futrue,而是使用对std::future的高级封装std::async

mutex mtx;
string GetCurrentDateTime()
{SYSTEMTIME stime;GetLocalTime(&stime);stringstream ss;unique_lock lock(mtx);ss << "[" << this_thread::get_id() << "]" << "current time: " << stime.wYear << "/" << stime.wMonth \<< "/" << stime.wDay << "/" << stime.wHour << "/" << stime.wMinute << "/" << stime.wSecond << endl;this_thread::sleep_for(chrono::seconds(2));return ss.str();
}int main()
{future fu = async(GetCurrentDateTime);//执行一个异步任务来获取当前时间cout << this_thread::get_id() << " : main do something..." << endl;cout << fu.get() << endl;return 0;
}

在这里插入图片描述

上述代码中,main线程通过async创建一个新线程去执行异步任务(获取当前系统时间),在新线程执行异步任务的过程中,main线程可以不必阻塞,但在调用get方法时,如果新线程没有返回,就会被阻塞

我们可以通过wait_for进行超时等待返回结果,如果新线程还没返回,就做其他事情,再重复wait_for

mutex mtx;
string GetCurrentDateTime()
{SYSTEMTIME stime;GetLocalTime(&stime);stringstream ss;unique_lock lock(mtx);ss << "[" << this_thread::get_id() << "]" << "current time: " << stime.wYear << "/" << stime.wMonth \<< "/" << stime.wDay << "/" << stime.wHour << "/" << stime.wMinute << "/" << stime.wSecond << endl;this_thread::sleep_for(chrono::seconds(3));//休眠3秒return ss.str();
}int main()
{std::future_status status;future fu = async(GetCurrentDateTime);cout << this_thread::get_id() << " : main do something..." << endl;do{status = fu.wait_for(chrono::milliseconds(500));if (status == std::future_status::deferred){cout << "deferred:异步操作还没开始," << "main do something" << endl;}else if (status == std::future_status::timeout){cout << "timeout:在规定时间内异步操作还未完成," << "main do something" << endl;}else if (status == std::future_status::ready){cout << "ready:异步操作已经完成,当前时间为:" << fu.get();}} while (status != std::future_status::ready);return 0;
}

在这里插入图片描述

上述代码中,main线程调用了wait_for(chrono::milliseconds(500)),表示mian线程等待500ms,如果在500ms内,子线程完成异步任务,则立刻返回,如果超过500ms还没有完成异步任务,则不会继续等待,立刻返回

future不允许直接赋值或者拷贝,但允许移动赋值

void func(){}int main()
{future fu1;future fu2 = async(std::launch::async, func);if (fu2.valid()){cout << "fu2.valid()=true" << endl;cout << "move..." << endl;fu1 = std::move(fu2);cout << "fu2.valid()=" <cout << "fu2.valid()=false" << endl;}return 0;
}

在这里插入图片描述

get成功之后,future对象将不再有效

string func()
{return "fl";
}int main()
{future fu = async(std::launch::async, func);if (fu.valid()){cout << "fu.get() begin fu.valid()=" << fu.valid() << endl;cout << "fu.get()=" << fu.get() << endl;cout << "fu.get() after fu.valid()=" << fu.valid() << endl;}return 0;
}

在这里插入图片描述

1.2 std::shared_future

shared_futrue原型

template   shared_future;
template  shared_future; 
template <>         shared_future; 

C++11中的std: :shared_future是个模板类。与std::future类似,std::shared_future提供了一种访问异步操作结果的机制。不同于std::future,std::shared_futrue允许多个线程等待同一个共享状态。不同于std::future仅支持移动操作,std::shared_future既支持移动操作也支持拷贝操作,而多个std::shared_future对象可以引用相同的共享状态

前面谈到,对于std::future对象,如果就绪,使用get后,future对象就无效了,如果再使用get,则会抛异常。使用std::shared_future就很好的解决了这个问题

string func()
{return "fl";
}int main()
{shared_future fu = async(std::launch::async, func);if (fu.valid()){cout << "fu.get()=" << fu.get() << endl;cout << "fu.get()=" << fu.get() << endl;cout << "fu.get()=" << fu.get() << endl;}else{cout << "fu.valid()=false" << endl;}return 0;
}

在这里插入图片描述

支持拷贝和赋值

string func()
{return "fl";
}int main()
{shared_future fu = async(std::launch::async, func);shared_future fu1 = fu;shared_future fu2(fu1);if (fu.valid()){cout << "fu.get()=" << fu.get() << endl;cout << "fu1.get()=" << fu.get() << endl;cout << "fu2.get()=" << fu.get() << endl;}else{cout << "fu.valid()=false" << endl;}return 0;
}

在这里插入图片描述

2、std::async

std::async比std::future和std::promise、std::packaged和std::thread更高一层,它可以用来直接创建异步的task,异步任务返回的结果也保存在std::future中,需要获取异步任务的结果时,只需要调用future.get()方法即可,如果不关注异步任务的结果,只是简单地等待任务完成时的话,则调用future.wait()方法

async原型

template future::type>async (Fn&& fn, Args&&... args);template future::type>async (launch policy, Fn&& fn, Args&&... args);

后者比前者多了一个参数:launch policy,这个表示线程的创建策略,有两种策略,默认的策略是立即创建线程

  1. std::launch::async:在调用async时就开始创建线程
  2. std::launch::deferred:延迟加载方式创建线程。在调用async时不创建线程,知道调用了future的get或者wait时才创建线程

第二个参数:表示线程的入口函数,必须是一个可调用对象
第三个参数:表示线程函数的参数

std::async的操作,其实相当于封装了std::promise、std::packaged_task加上std::thread

使用std::launch::deferred作为参数

mutex mtx;
string GetCurrentDateTime()
{SYSTEMTIME stime;GetLocalTime(&stime);stringstream ss;unique_lock lock(mtx);ss << "[" << this_thread::get_id() << "]" << "current time: " << stime.wYear << "/" << stime.wMonth \<< "/" << stime.wDay << "/" << stime.wHour << "/" << stime.wMinute << "/" << stime.wSecond << endl;cout << "in GetCurrentDateTime()" << endl;return ss.str();
}int main()
{future fu = async(std::launch::deferred, GetCurrentDateTime);this_thread::sleep_for(chrono::milliseconds(500));cout << "main id is " << this_thread::get_id() << endl;cout << fu.get() << endl;return 0;
}

在这里插入图片描述
可以看到GetCurrentDateTime()也是有main线程执行的。在上述的执行顺序中,main线程先打印了自己的线程id,然后调用fu.get()时进入GetCurrentDateTime()内部,完成任务后才打印的时间。因此就能很好的证明deferred参数确实是在创建async时,不创建线程执行任务,而是在调用get方法时,由main线程去执行异步任务。

将参数改为async,执行结果为:

在这里插入图片描述

可以看到,在调用async时就开始创建线程去执行异步任务。

如果我们没有指定第一个参数,默认是async | deferred,具体采用哪个参数,取决于操作系统
在这里插入图片描述

3、std::promise

std::promise将数据和future绑定起来,为获取线程函数中的某个值提供便利,在线程函数中为外面传进来的promise赋值,在线程函数执行完成之后就可以通过promise的future获取该值了。值得注意的是:取值是间接地通过promise内部提供的future来获取的。

std::promise原型

template   promise;		 //空模板
template  promise;     //用于线程间交流对象
template <>         promise;   //用于交流无状态事件

成员方法
在这里插入图片描述

举个例子,简单了解一下promise和future是如何关联的

void func1(std::promise& promObj)
{cout << this_thread::get_id() << "设置promise的值" << endl;promObj.set_value(5);
}void func2(std::future& fut)
{cout << this_thread::get_id() << "访问promise的值" << endl;cout << this_thread::get_id() << ":" << fut.get() << endl;
}int main()
{std::promise prom;std::future fut = prom.get_future();std::thread t1(func1, std::ref(prom));std::thread t2(func2, std::ref(fut));t1.join();t2.join();return 0;
}

在这里插入图片描述

在上述代码中,我们定义一个std::promise prom,并让其与std::future fut进行关联。让t1线程去调用fun11,t2线程去调用func2。如果t2线程在func2中调用fut.get()时,而fut并没有被设置,此时f2线程会被阻塞,直到t1线程在func1中调用promObj.set_value(5),例如:

在这里插入图片描述
std::promise的operator=没有拷贝语义,即std::promise的普通赋值函数是被delete掉了,只有move语义,因此std::promise对象是禁止拷贝的

int main()
{std::promise prom;std::future fut = prom.get_future();std::promise prom1 = prom;return 0;
}

在这里插入图片描述

采用set_value_at_thread_exit演示一下死锁

mutex mtx;
void func1(std::promise& promObj)
{this_thread::sleep_for(chrono::microseconds(500));promObj.set_value_at_thread_exit(1);unique_lock lock(mtx);cout << this_thread::get_id() << "设置promise的值" << endl;
}void func2(std::future& fut)
{unique_lock lock(mtx);cout << this_thread::get_id() << "访问promise的值" << endl;cout << this_thread::get_id() << ":" << fut.get() << endl;
}int main()
{std::promise prom;std::future fut = prom.get_future();thread t1(func1, std::ref(prom));thread t2(func2, std::ref(fut));t1.join();t2.join();return 0;
}

在这里插入图片描述
为了让func2中的代码先执行,在func1的开始调用了sleep_for(chrono::microseconds(500)),休眠500微秒。首先f2线程拿到锁,执行到fut.get()会被阻塞,因为此时fut还未就绪。线程t1使用set_value_at_thread_exit(1),表明设置指定值为1,但是只有在t1线程结束时,才提醒。因此t1线程将被阻塞在unique_lock lock(mtx)上,而t2线程被阻塞在fut.get()上,所以产生了死锁。

使用set_value_at_thread_exit好处就是确保某个线程的退出,另一个线程才能被获取到某个值,例如:

void func1(std::promise& promObj)
{promObj.set_value(1);cout << this_thread::get_id() << "设置promise的值" << endl;cout << "do something..." << endl;cout << "do something..." << endl;cout << "do something..." << endl;cout << "do something..." << endl;
}void func2(std::future& fut)
{cout << this_thread::get_id() << "访问promise的值" << endl;cout << this_thread::get_id() << ":" << fut.get() << endl;
}int main()
{std::promise prom;std::future fut = prom.get_future();thread t1(func1, std::ref(prom));thread t2(func2, std::ref(fut));t1.detach();t2.join();return 0;
}

在这里插入图片描述
t1线程进行了分离,t2线程先结束,也就导致了main线程结束了,t1线程在后台执行,并没有将"do something…"打印到终端上。因此可以使用set_value_at_thread_exit使t2线程等待t1线程结束

在这里插入图片描述

一个线程将异常传递给另一个线程

void func1(std::promise& p)
{try{cout << this_thread::get_id() << " throw error" << endl;throw exception("this is func1 throw error");}catch (const std::exception& e){p.set_exception_at_thread_exit(std::current_exception());}
}void func2(std::future& fu)
{try{if (fu.valid())fu.get();}catch (const std::exception e){cout << this_thread::get_id() << " error is " << e.what() << endl;}
}int main()
{std::promise p;std::future fu = p.get_future();thread t1(func1, std::ref(p));thread t2(func2, std::ref(fu));t1.join();t2.join();return 0;
}

在这里插入图片描述

4、std::packaged_task

std:packaged _task 包装了一个可调用对象的包装类(如function、lambda expression、bind expression和another function object),将函数和future绑定起来,以便异步调用,它和std:promise在某种程度上有点像,promise保存了一个共享状态的值,而packaged task 保存的是一个函数。

std::packaged_task原型

template  packaged_task;     // undefined
template  class packaged_task;

成员函数

在这里插入图片描述

简单案例

int f(int x, int y) { return std::pow(x, y); }void task_lambda()
{std::packaged_task task([](int a, int b) {return std::pow(a, b);});std::future result = task.get_future();//auto result = task.get_future();task(2, 2);std::cout << "task_lambda:\t" << result.get() << '\n';
}void task_bind()
{std::packaged_task task(std::bind(f, 2, 3));std::future result = task.get_future();//auto result = task.get_future();task();std::cout << "task_bind:\t" << result.get() << '\n';
}void task_thread()
{std::packaged_task task(f);std::future result = task.get_future();std::thread task_td(std::move(task), 2, 4);task_td.join();std::cout << "task_thread:\t" << result.get() << '\n';
}int main()
{task_lambda();task_bind();task_thread();return 0;
}

在这里插入图片描述

相关内容

热门资讯

安卓系统限制无法录音,探索无法... 你有没有遇到过这种情况?手机里明明装了录音软件,却突然发现,哎呀妈呀,竟然无法录音了!这可真是让人头...
怎么降级手机系统安卓,操作指南... 手机系统升级了,新功能层出不穷,但有时候,你可能会觉得,这系统太卡了,想回到那个流畅如丝的年代。别急...
米oa系统是安卓系统吗,深入解... 亲爱的读者,你是否曾好奇过,米OA系统是不是安卓系统的一员?这个问题,就像是一颗好奇的种子,悄悄地在...
手机刷安卓车载系统,手机刷机后... 你有没有发现,现在开车的时候,手机和车载系统之间的互动越来越紧密了呢?想象当你驾驶着爱车,一边享受着...
vivo安卓怎么降系统,viv... 手机用久了,是不是觉得系统越来越卡,运行速度大不如前?别急,今天就来教你怎么给vivo安卓手机降降级...
nova 4刷安卓系统,体验全... 最近手机界可是热闹非凡呢!听说华为nova 4要刷安卓系统了,这可真是让人兴奋不已。你有没有想过,你...
如果当初没有安卓系统,科技世界... 想象如果没有安卓系统,我们的生活会是怎样的呢?是不是觉得有点不可思议?别急,让我们一起穿越时空,探索...
安卓电视装win系统,系统转换... 亲爱的读者们,你是否曾想过,在你的安卓电视上装一个Windows系统,让它瞬间变身成为一台功能强大的...
安卓手机还原系统好处,重拾流畅... 你有没有遇到过安卓手机卡顿、运行缓慢的情况?别急,今天就来给你揭秘一下安卓手机还原系统的那些好处,让...
安卓系统能跑win吗,探索跨平... 你有没有想过,你的安卓手机里能不能装上Windows系统呢?这听起来是不是有点像科幻电影里的情节?别...
安卓车载系统蓝牙设置,畅享智能... 你有没有发现,现在开车的时候,手机和车载系统之间的互动越来越频繁了呢?这不,今天就来给你详细说说安卓...
奥利奥安卓系统,探索新一代智能... 你有没有想过,一块小小的奥利奥饼干竟然能和强大的安卓系统扯上关系?没错,今天就要来聊聊这个跨界组合,...
微信使用安卓系统,功能解析与操... 你有没有发现,现在用微信的人越来越多了呢?尤其是安卓系统的用户,简直就像潮水一样涌来。今天,就让我带...
体验最新原生安卓系统,极致体验... 你有没有想过,手机系统就像是我们生活的调味品,有时候换一种口味,生活都会变得有趣起来呢?最近,我体验...
安卓系统能玩原神,尽享奇幻冒险... 你有没有想过,在安卓系统上也能畅玩《原神》这样的热门游戏呢?没错,就是那个画面精美、角色丰富、玩法多...
安卓写手机银行系统,基于安卓平... 你有没有想过,手机银行系统在我们日常生活中扮演了多么重要的角色呢?每天刷刷手机,就能轻松管理账户,转...
僵尸之夜恐怖安卓系统,揭秘恐怖... 僵尸之夜,恐怖安卓系统来袭!想象一个寂静的夜晚,你正沉浸在美梦中,突然,一阵诡异的铃声打破了夜的宁静...
谷歌框架和安卓系统,构建智能移... 你有没有想过,为什么你的手机那么聪明,能帮你找到路线,还能帮你拍出美美的照片呢?这都要归功于一个超级...
安卓系统和oppo系统哪个流畅... 你有没有想过,手机系统哪个更流畅呢?安卓系统和OPPO系统,这两个名字听起来就让人心动。今天,咱们就...
安卓怎么用微软系统,利用微软系... 你是不是也和我一样,对安卓手机上的微软系统充满了好奇?想象那熟悉的Windows界面在你的安卓手机上...