问题1: 如何理解线程异步?
异步的反义词是同步。异步与同步的区别见此处: [[Linux/计算机网络基础知识点/高级IO#同步通信 vs 异步通信]]。实际上在多线程下，大部分时候都是存在过异步这一状态的。主线程在创建了子线程后，也去干自己的任务了。
问题2: 线程异步的应用场景?
future对象进行存储。(future是个模板类, 能存储任意类型, 包括void) //子—>主
//包含于<future>头文件
template <class T> future;
template <class R&> future<R&>; // specialization : T is a reference type (R&)
template <> future<void>; // specialization : T is void
//---------------------------------------------------
//构造函数
future() noexcept; //(1) default
future (const future&) = delete; //(2) copy [deleted]
future (future&& x) noexcept; //(3) move
//赋值
future& operator=(future&& other) noexcept;
future& operator=(const future& other) = delete;
future对象是用于存储某一类型<class T>的值的，只不过这个值往往是在未来才能获取到。 它被用来作为线程异步的中间存储值。future的值由以下三个异步任务的提供者(Provider)提供:
std::promisestd::package_taskstd::async 我们根据future的构造函数可以发现，future不支持拷贝构造。future的operator=()会去调用移动构造。
future在线程异步当中扮演的是一个被动角色。它需要与promise、package_task、async配合来实现线程异步。由于它必须要进行共享关联，因此future对象时存在共享状态是否有效的问题的。只有共享状态有效，才能获取future的值。
future对象是有"共享状态"这一概念的。共享状态必须依靠上面提到的三者对应的方法: promise::get_future()、package_task::get_future()、async()获取。否则单纯的创建一个future对象, 它的共享状态是无效的!
| 共享状态 | 解释 |
|---|---|
| future_status::deferred | 子线程中的任务函仍未启动 |
| future_status::timeout | 子线程中的任务正在执行中，指定等待时长已用完 |
| future_status::ready | 子线程中的任务已经执行完毕，结果已就绪 |
实际上，为了方便我们理解，还应该加一个状态: 无效状态(invalid)。这个状态存在于:
①future对象没有接收任何提供者的共享关联;
②future对象ready完毕后，被调用者通过get()获取过了。
| 成员函数 | 功能 |
|---|---|
| valid() | 判断共享状态是否有效 |
| wait() | 等待共享状态ready |
| wait_for() | 等待一段时间 |
| wait_until() | 等待到某个时间点 |
| get() | 获取future的值 |
注意:
get()时，如果future的共享状态不是ready, 则调用者会被阻塞。get()只能被调用一次，第二次会抛出异常。(因为第一次完成后，future的状态就是无效的了)wait()方法会阻塞式等待共享状态为ready。wait_for()和wait_until()无法保证等待结束后的future对象的状态一定是ready! (所以它们不太常用, 因为调用完毕后还需要使用valid()判断共享状态)wait_for()和wait_until()的返回值是std::future_status。因此我们可以通过接收它们的返回值来循环判断future对象是否ready。
//包含于<future>头文件
template <class T> promise;
template <class R&> promise<R&>; // specialization : T is a reference type (R&)
template <> promise<void>;// specialization : T is void
//构造函数
promise(); //(1)
promise(promise&& other) noexcept; //(2) 移动构造
promise(const promise& other) = delete; //(3) 禁止拷贝构造
//赋值
promise& operator= (promise&& rhs) noexcept; //允许移动赋值
promise& operator= (const promise&) = delete;//禁止拷贝赋值
promise是一个协助线程赋值的类，在promise类的内部管理着一个future对象。因此它能够提供一些将数据和future对象绑定起来的接口。
| 成员函数 | 功能 |
|---|---|
| get_future() | 获取future对象 |
| set_value() | 设置future对象的值(立刻) |
| set_value_at_thread_exit() | 在线程结束时，才会设置future对象的值, |
• get_future()
get_future()会返回一个future对象, 此时如果去接收它的返回值则会触发移动赋值, 将资源转移。
• set_value()
设置future对象的值，并立即设置future对象的共享状态为ready。
• set_value_at_thread_exit()
设置future对象的值，但是不会立刻让future对象的共享状态为ready。在子线程退出时，子线程资源被销毁，再令共享状态为ready。
①: 子线程 set_value—> 给主线程
promise对象promise对象通过引用传递的方式传给子线程的任务函数(ref)set_value()方法, 设置future对象的值以及状态(ready)promise对象中的get_future()方法获取到future对象 (这里是移动构造了)future对象中的get()方法获取到子线程set_value()所设置的值。void func(promise<int>& pr)
{
cout << "Child Thread Working~~~" << endl;
cout << "Child Thread: Waiting 3 seconds!" << endl;
this_thread::sleep_for(chrono::seconds(3));
pr.set_value(3);
this_thread::sleep_for(chrono::seconds(1));
cout << "Child Exit" << endl;
}
int main()
{
promise<int> pr;
thread t(func, ref(pr));
auto f = pr.get_future();
this_thread::sleep_for(chrono::seconds(1));
cout << "Get Future: " << f.get() << endl;
t.join();
return 0;
}
注意:
根据现象, 我们可以发现主线程在调用f.get()时阻塞了一会。此时说明子线程还没有执行到set_value(), 此时的future对象中的共享状态不是ready, 因此主线程会被阻塞。
②: 主线程 set_value–> 给子线程
promise对象promise对象通过引用传递的方式传给子线程的任务函数(ref)set_value()方法, 设置future对象的值以及状态(ready)future对象的值的判断条件，当future的共享状态或者值满足条件时，执行某一任务(或终止)void func2(promise<int>& pr)
{
int i = 0;
auto val = pr.get_future().get();
if(val == 1){
cout << "Get Value: " << val << endl;
//do something
}
else{
cout << "Get Value: " << val << endl;
//do something
}
}
int main()
{
promise<int> pr;
thread t(func2, ref(pr));
cout << "Main Thread: Waiting 3 seconds!" << endl;
this_thread::sleep_for(chrono::seconds(3));
pr.set_value(1);
t.join();
}
输出:
Main Thread: Waiting 3 seconds!
Get Value: 1
//包含于<future>头文件
template <class T> packaged_task; // undefined
template <class Ret, class... Args> class packaged_task<Ret(Args...)>;
//构造函数
packaged_task() noexcept; //default (1)
template <class Fn>
explicit packaged_task (Fn&& fn); //initialization (2)
packaged_task (const packaged_task&) = delete; //copy [deleted] (3)
packaged_task (packaged_task&& x) noexcept; //move (4)
//赋值
packaged_task& operator=(packaged_task&& rhs) noexcept; //move (1)
packaged_task& operator=(const packaged_task&) = delete;//copy [deleted] (2)
package_task包装了一个函数对象(类似于function), 我们可以把它当做函数对象来使用。package_task可以将内部包装的函数和future绑定到一起，以便于进行后续的异步调用。因此我们可以将其理解为它自带了一个函数，并且该函数和future对象绑定到了一起，我们不需要额外定义函数方法了，直接实现package_task中的函数对象即可。
但package_task相比于promise有个缺点，它里面包装了函数，而该函数的返回值就是future对象的值。它无法像使用promise那样灵活。
package_task中最常用的就是get_future()方法了。它能够获取到package_task中的future对象。
将package_task作为线程的启动函数传过去，传参方式必须是引用传递 ref()。
int main()
{
packaged_task<int(int, int)> pt_Add([](int x, int y)
{
cout << "Running~~~~~~~~~~" << endl;
this_thread::sleep_for(chrono::seconds(3));
return x + y;
});
future<int> fi = pt_Add.get_future();
cout << "Start Thread!" << endl;
thread t(ref(pt_Add), 10, 20);
cout << "before get" << endl;
int val = fi.get();
cout << "val: " << val << endl;
t.join();
return 0;
}
输出:
Start Thread!
before get
Running~~~~~~~~~~
val: 30
//构造函数
// (1)
template<class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type>
async (Fn&& fn, Args&&... args);
// (2)
template<class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type>
async (launch policy, Fn&& fn, Args&&... args); //policy是启动策略
async是一个函数，它相比于前面的promise和package_task要高级一些。async可以直接启动一个子线程，然后让这个子线程执行对应的任务函数，任务函数的返回值就会被存储到future对象当中，future对象也就是async函数的返回值。主线程只需要接收asnyc的返回值，然后调用get()方法即可获取到future对象中保存的值。
注: 更高级并不代表更好用，只是它的集成度更高一些，省去了我们要自己创建线程的步骤。async仍然有package_task的缺点，它无法像promise那样自由控制future在何时赋值。
• launch policy启动策略
| 策略 | 解释 |
|---|---|
| std::launch::async | 调用async函数时会创建新的线程，让该线程执行任务函数 |
| std::launch::deferred | 调用async函数时不会创建新的线程，也不会去执行该任务函数。只有调用了async返回的future的get()方法或者wait()方法时才会去执行任务。(执行该任务的是主线程) |
• 使用默认的启动策略 — 调用async创建子线程, 并让该线程去执行任务
int main()
{
future<int> f = async([](int x, int y)
{
cout << "Child Thread: Waiting 3 seconds!" << endl;
this_thread::sleep_for(chrono::seconds(3));
return x + y;
}, 10, 20);
this_thread::sleep_for(chrono::seconds(1));
cout << "Get Value: " << f.get() << endl;
return 0;
}
输出:
Child Thread: Waiting 3 seconds!
Get Value: 30
• 使用deferred启动策略 — 调用async不创建子线程
int main()
{
future<int> f = async(launch::deferred, [](int x, int y)
{
cout << "Child Thread "<< this_thread::get_id() << ": Waiting 3 seconds!" << endl;
this_thread::sleep_for(chrono::seconds(3));
return x + y;
}, 10, 20);
cout << "Main Thread "<< this_thread::get_id() <<": Working!!!" << endl;
auto val = f.get();
cout << "Get Value: " << val << endl;
return 0;
}
输出:
Main Thread 1: Working!!!
Child Thread 1: Waiting 3 seconds!
Get Value: 30
我们可以发现使用deferred策略时，是不会创建新的线程的。也就是说async的任务函数依然是由主线程自己去执行的，只不过执行的时机可以控制 (在调用get()方法时会去执行)，这个机制类似于回调函数，你主动去调用get()才会去回调执行async的任务。
细节总结:
get_future()方法, 并不会让线程被阻塞。只要调用future对象的get()方法，才可能被阻塞。(future共享状态没有ready就会被阻塞, 前提是future共享状态有效)ref()的时机。