future
C++11异步编程(std::async, std::future, std::packaged_task, std::promise)-腾讯云开发者社区-腾讯云 (tencent.com)
来自 promise 的 future
- 例子1：主线程从子线程获取值
#include <iostream>
#include <future>
#include <thread>
void task(int a, int b, std::promise<int>& p) {
p.set_value(a+b); // set value to promise
}
int main() {
std::promise<int> p; // create a promise
std::future<int> f = p.get_future(); // create a future bind to promise
std::thread t1(task, 1, 2, std::ref(p)); // pass promise to child thread
f.wait(); // wait for promise's result by future
std::cout << f.get() << std::endl; // get promise's result by future
t1.join(); // wait for child thread
return 0;
}
- 例子2：主线程向子线程传入值，再获取值
#include <iostream>
#include <future>
#include <thread>
void task(std::future<int>& fa, std::future<int>& fb, std::promise<int>& p) {
// set value to promise
p.set_value(fa.get() + fb.get());
}
int main() {
// create promise
std::promise<int> a, b, p;
// set value to promise
a.set_value(1);
b.set_value(2);
// create a future bind to promise (a\b\p)
std::future<int> fa = a.get_future();
std::future<int> fb = b.get_future();
std::future<int> fp = p.get_future();
// pass promise to child thread
std::thread t1(task, std::ref(fa), std::ref(fb), std::ref(p));
// wait for promise's result by future
fp.wait();
// get promise's result by future
std::cout << fp.get() << std::endl;
// wait for child thread
t1.join();
return 0;
}
来自 async() 的 future
- 例子1：不开新线程的async。std::launch::deferred，那么线程的执行就会推迟到std::future.get()方法时才会启动，如果不使用get或者wait时，线程直接结束，不会执行线程入口函数内的东西如果使用的话，也会发现，根本没有创建新的线程，就是在主线程中调用的线程入口函数。
#include <iostream>
#include <future>
#include <thread>
using namespace std;
int task(int a, int b) {
return a + b;
}
int main() {
// bind future to async
std::future<int> f = std::async(std::launch::deferred, task, 1, 2);
//get future value
f.wait();
std::cout << f.get() << std::endl;
return 0;
}
- 例子2：开新线程的async。std::launch::async（系统默认使用的就是这个参数）意思是自动创建一个线程，执行线程的入口函数，返回一个std::future对象 std::future可以得到线程入口函数的返回结果，使用方法get()即可 但是get函数只能调用一次，不能调用多次
#include <iostream>
#include <future>
#include <thread>
using namespace std;
int task(int a, int b) {
return a + b;
}
int main() {
// bind future to async
std::future<int> f = std::async(std::launch::async, task, 1, 2);
// same to previous
// std::future<int> f = std::async(task, 1, 2);
//get future value
f.wait();
std::cout << f.get() << std::endl;
return 0;
}
来自 packaged_task 的 future
打包一个函数，存储其返回值以进行异步获取
- 不使用bind
#include <iostream>
#include <future>
#include <thread>
using namespace std;
int task(int a, int b) {
return a + b;
}
int main() {
// create packaged_task
std::packaged_task<int(int, int)> t(task);
// execute task
t(1, 2);
// get future
std::future<int> f = t.get_future();
// get value
f.wait();
std::cout << f.get() << std::endl;
return 0;
}
- 使用bind，提前指定参数
#include <iostream>
#include <future>
#include <thread>
#include <functional>
int task(int a, int b) {
return a + b;
}
int main() {
// create packaged_task
std::packaged_task<int()> t(std::bind(task, 1, 2));
// execute task
t();
// get future
std::future<int> f = t.get_future();
// get value
f.wait();
std::cout << f.get() << std::endl;
return 0;
}
shared_future
类模板 std::shared_future 提供访问异步操作结果的机制，类似 std::future ，除了允许多个线程等候同一共享状态。不同于仅可移动的 std::future （故只有一个实例能指代任何特定的异步结果），std::shared_future 可复制而且多个 shared_future 对象能指代同一共享状态。
若每个线程通过其自身的 shared_future 对象副本访问，则从多个线程访问同一共享状态是安全的。
#include <iostream>
#include <future>
#include <chrono>
int main()
{
std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise;
std::shared_future<void> ready_future(ready_promise.get_future());
std::chrono::time_point<std::chrono::high_resolution_clock> start;
auto fun1 = [&, ready_future]() -> std::chrono::duration<double, std::milli>
{
t1_ready_promise.set_value();
ready_future.wait(); // 等待来自 main() 的信号
return std::chrono::high_resolution_clock::now() - start;
};
auto fun2 = [&, ready_future]() -> std::chrono::duration<double, std::milli>
{
t2_ready_promise.set_value();
ready_future.wait(); // 等待来自 main() 的信号
return std::chrono::high_resolution_clock::now() - start;
};
auto result1 = std::async(std::launch::async, fun1);
auto result2 = std::async(std::launch::async, fun2);
// 等待线程变为就绪
t1_ready_promise.get_future().wait();
t2_ready_promise.get_future().wait();
// 线程已就绪，开始时钟
start = std::chrono::high_resolution_clock::now();
// 向线程发信使之运行
ready_promise.set_value();
std::cout << "Thread 1 received the signal "
<< result1.get().count() << " ms after start\n"
<< "Thread 2 received the signal "
<< result2.get().count() << " ms after start\n";
}
coroutine
概念
在C++中，只要在函数体内出现了 co_await 、co_return 和 co_yield 这三个操作符中的其中一个，这个函数就成为了协程。
限制：
- 不能使用可变参数
- 不能使用普通的return语句
- 返回类型不能为auto或者Concept
- Consteval functions, constexpr functions, constructors, destructors, and the main function 都不能是coroutine
三个关键字
- the co_await expression — to suspend execution until resumed
- the co_yield expression — to suspend execution returning a value
- the co_return statement — to complete execution returning a value
相关对象
- promise ：从协程内部操作。协程通过此对象提交其结果或异常。
- coroutine handle：从协程外部操作。这是一个非拥有句柄，用于恢复协程的执行或销毁协程帧。
- coroutine state：它是内部动态分配的存储（除非分配被优化），包含
- Promise 对象
- 参数（均按值复制）
- 当前挂起点的一些表示形式，以便恢复知道在哪里继续，而销毁知道范围内有哪些局部变量
- 局部变量和临时变量，其生存期跨越当前挂起点。
执行流程
- 使用运算符 new 分配协程状态对象。
- 将所有函数参数复制到协程状态：按值参数被移动或复制，按引用参数仍为引用。（因此，如果在引用对象的生存期结束后恢复协程，则可能会悬空 - 请参阅下面的示例）
- 调用 promise 对象的构造函数。（如果 promise 类型有一个构造函数的参数与协程的参数完全相同，则使用复制后的协程参数来调用该构造函数。否则，将调用默认构造函数。）
- 调用
promise.get_return_object()并将结果保留在局部变量中。当协程首次挂起时，该调用的结果将返回给调用方。（引发到此步骤（包括此步骤）的任何异常都会传播回调用方，而不是放在 promise 中。） - 调用
promise.initial_suspend()并且co_await它的结果(相当于co_await promise.initial_suspend())。典型类型要么返回 std::suspend_always（用于延迟启动的协程），要么返回 std::suspend_never（用于急切启动的协程）。
示例程序
示例程序，主要用到了co_return和co_yeild。
#include <coroutine>
#include <iostream>
template<class T>
struct Task {
struct promise_type;
using handle = std::coroutine_handle<promise_type>;
struct promise_type {
Task get_return_object() {
std::cout << "Task::promise_type::get_return_object()" << std::endl;
return {std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() {
std::cout << "Task::promise_type::initial_suspend()" << std::endl;
return {};
}
std::suspend_always final_suspend() noexcept {
std::cout << "Task::promise_type::final_suspend()" << std::endl;
return {};
}
void return_value(T val) {
std::cout << "Task::promise_type::return_value()" << std::endl;
m_val = val;
}
std::suspend_always yield_value(T val) {
std::cout << "Task::promise_type::yield_value()" << std::endl;
m_val = val;
return {};
}
void unhandled_exception() {
std::terminate();
}
T m_val;
};
Task() : m_handle(nullptr) {
std::cout << "Task::Task()" << std::endl;
}
Task(handle h): m_handle(h){}
Task(const Task& rhs) = delete;
Task(Task&& rhs) noexcept
: m_handle(rhs.m_handle) {
rhs.m_handle = nullptr;
}
Task& operator=(const Task& rhs) = delete;
Task& operator=(Task&& rhs) noexcept {
if (std::addressof(rhs) != this)
{
if (m_handle)
{
m_handle.destroy();
}
m_handle = rhs.m_handle;
rhs.m_handle = nullptr;
}
return *this;
}
T get() {
std::cout << "Task::get()" << std::endl;
return m_handle.promise().m_val;
}
void resume() {
std::cout << "Task::resume()" << std::endl;
m_handle.resume();
}
bool done() {
std::cout << "Task::done()" << std::endl;
return !m_handle || m_handle.done();
}
void destroy() {
std::cout << "Task::destroy()" << std::endl;
m_handle.destroy();
m_handle = nullptr;
}
~Task() {
std::cout << "Task::~Task()" << std::endl;
if (m_handle) {
m_handle.destroy();
}
}
private:
handle m_handle = nullptr;
};
Task<int> generator_int() {
std::cout << "begin ........" << std::endl;
std::cout << "before co_yield 1" << std::endl;
co_yield 1;
std::cout << "after co_yield 1, before co_yield 2" << std::endl;
co_yield 2;
std::cout << "after co_yield 2, before co_return 3" << std::endl;
co_return 3;
std::cout << "after co_return 3" << std::endl;
std::cout << "end ........." << std::endl;
}
int main() {
Task<int> gen = generator_int();
gen.resume();
std::cout << "main: first calll get()" << std::endl;
std::cout << gen.get() << std::endl;
gen.resume();
std::cout << "main: second calll get()" << std::endl;
std::cout << gen.get() << std::endl;
gen.resume();
std::cout << "main: third calll get()" << std::endl;
std::cout << gen.get() << std::endl;
return 0;
}
程序输出
Task::promise_type::get_return_object()
Task::promise_type::initial_suspend()
Task::resume()
begin ........
before co_yield 1
Task::promise_type::yield_value()
main: first calll get()
Task::get()
1
Task::resume()
after co_yield 1, before co_yield 2
Task::promise_type::yield_value()
main: second calll get()
Task::get()
2
Task::resume()
after co_yield 2, before co_return 3
Task::promise_type::return_value()
Task::promise_type::final_suspend()
main: third calll get()
Task::get()
3
Task::~Task()
扫一扫
210
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
