future/promise
future提供了一个基于数据(future模板类型)的异步概念：对于一个类型T，可以在以后通过get接口获得这个类型T的变量。或者打个不太恰当的比方，当你获得一个future对象时，就获得了一个消费券(consumer)：拿着这张券可以兑换(get)一个T类型的结果(如果数据未就绪的话会阻塞等待)。至于这个类型是从哪里来的future对象本身并不关系，它是future提供者的职责。
事实上，从future的文档(为了方便阅读单独拷贝一份)就可以看到，除了promise之外，还有std::async、std::packaged_task也可以提供future。promise只是抽象了一种数据结构(但是没有提供具体如何异步)，这种数据结构支持set_value和future::get的时序/等待/状态/异常处理等常用逻辑。当数据就绪之后，直接通过promise::set_value生产数据即可。至于这个set_value从哪里来，promise本身也不关系(它只是一个数据结构)，需要具体生产者负责。
#include <future>
#include <iostream>
#include <thread>
int main()
{
// future from a packaged_task
std::packaged_task<int()> task([]{ return 7; }); // wrap the function
std::future<int> f1 = task.get_future(); // get a future
std::thread t(std::move(task)); // launch on a thread
// future from an async()
std::future<int> f2 = std::async(std::launch::async, []{ return 8; });
// future from a promise
std::promise<int> p;
std::future<int> f3 = p.get_future();
std::thread([&p]{ p.set_value_at_thread_exit(9); }).detach();
std::cout << "Waiting..." << std::flush;
f1.wait();
f2.wait();
f3.wait();
std::cout << "Done!\nResults are: "
<< f1.get() << ' ' << f2.get() << ' ' << f3.get() << '\n';
t.join();
}
再笼统的说：promise和future大致相当于一个管道(Unix中pipe)文件的两个两端，分别是输入和读取数据的两端，具体数据如何产生，消费的数据如何处理，这种机制本身并不关心。
解耦
- 使用场景
future并不是一定依赖于promise的，其它的一些场景下也可以生成future。
- producer/consumer
promise中有set_value接口，而future中有get接口；这个描述还有一个对应的反面：promise没有get(value)接口，future没有set_value接口。
从逻辑上拆分之后，不通过类型的职责更加单一，也更易于理解使用场景。
- 生存期
当future生成(例如promise::get_future)之后，future可以从它的原始“生产地”中完全脱离出来。例如，如果promise在set_value之后对象本身析构。
问题
如果promise设置了值(set_value)之后，在future执行get之前析构，此时future的get还有效吗？
SO的答案说明：如果在销毁之前给promise提供了value，那么对应的std::future可以毫无压力的获得设置值。
If you provide a value to the std::promise before destroying it, the associated std::future will be able to retrieve it just fine. It does not depend on std::promise still existing. If you failed to provide a value to std::promise before destroying it, trying to get a result from the std::future will throw std::future_error but it is also well defined.
查看源代码中promise的析构函数，在析构的时候，判断如果_M_future非空，并且_M_future指向内容有多个shared_ptr引用，那么会设置_M_future为_M_break_promise。这样的话，通过future来get的时候，应该会抛出异常才对。到底是哪里出了问题呢？
~promise()
{
if (static_cast<bool>(_M_future) && !_M_future.unique())
_M_future->_M_break_promise(std::move(_M_storage));
}
测试
从测试来看，在promise析构之后，get_futre().get()的确可以毫无障碍的获得promise析构前设置的value。
tsecer@harry: cat dest_promise.cpp
#include <future>
#include <stdio.h>
int main(int argc, const char *argv[])
{
std::promise<int> *pp = new std::promise<int>;
std::future<int> of = pp->get_future();
pp->set_value(1234);
delete pp;
printf("future.get is %d\n", of.get());
return 0;
}
tsecer@harry: g++ dest_promise.cpp -g -lpthread
tsecer@harry: ./a.out
future.get is 1234
tsecer@harry:
原因
由于问题明显而必现，在调试的帮助下很容易知道问题的原因：在执行promise析构函数时，_M_storage内容已经为空，而在_M_break_promise函数中，会判断指针是否为空，在指针为空的情况下并不会设置broken_promise。
// Abandon this shared state.
void
_M_break_promise(_Ptr_type __res)
{
if (static_cast<bool>(__res))
{
__res->_M_error =
make_exception_ptr(future_error(future_errc::broken_promise));
// This function is only called when the last asynchronous result
// provider is abandoning this shared state, so noone can be
// trying to make the shared state ready at the same time, and
// we can access _M_result directly instead of through call_once.
_M_result.swap(__res);
// Use release MO to synchronize with observers of the ready state.
_M_status._M_store_notify_all(_Status::__ready,
memory_order_release);
}
}
那么_M_storage是何时清空的呢？
由于demo代码比较简单，可以跟踪到是在set_value的时候，经过多层调用，最后会执行到这里的operator()() 函数，其中有一个std::move(_M_promise->_M_storage)，在_M_storage是一个unique_ptr的情况下，move操作会导致复制的源内容被清空。
// set void
template<typename _Res>
struct _Setter<_Res, void>
{
static_assert(is_void<_Res>::value, "Only used for promise<void>");
typename promise<_Res>::_Ptr_type operator()() const
{ return std::move(_M_promise->_M_storage); }
promise<_Res>* _M_promise;
};
unique_ptr，明确说明了如果是一个右值引用，这种构造函数将会转移所有权(by transferring ownership)
- Constructs a unique_ptr by transferring ownership from u to *this and stores the null pointer in u. This constructor only participates in overload resolution if std::is_move_constructible
::value is true. If Deleter is not a reference type, requires that it is nothrow-MoveConstructible (if Deleter is a reference, get_deleter() and u.get_deleter() after move construction reference the same value).
回顾promise的结构及get_future
- 结构
promise包括两个结构，一个是通过shared_ptr指向的future结构(_M_future)，一个是通过unique_ptr指向的类型(promise参数中的类型)数据结构(_M_storage字段)。
/// Primary template for promise
template<typename _Res>
class promise
{
///...
typedef __future_base::_Ptr<_Res_type> _Ptr_type;
///...
shared_ptr<_State> _M_future;
_Ptr_type _M_storage;
///...
///...
}
其中的_Ptr_type是一个unique_ptr类型
/// Base class and enclosing scope.
struct __future_base
{
/// A unique_ptr for result objects.
template<typename _Res>
using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;
}
future内容如下
// Base class for various types of shared state created by an
// asynchronous provider (such as a std::promise) and shared with one
// or more associated futures.
class _State_baseV2
{
typedef _Ptr<_Result_base> _Ptr_type;
enum _Status : unsigned {
__not_ready,
__ready
};
_Ptr_type _M_result;
__atomic_futex_unsigned<> _M_status;
atomic_flag _M_retrieved = ATOMIC_FLAG_INIT;
once_flag _M_once;
可以看到其中除了同步、状态之外，还有一个指向类型的_M_result字段，它在执行_M_future初始化的时候并没有和_M_storage关联起来。
- 分配
在promise的缺省构造函数中会为分配对应的存储空间。
promise()
: _M_future(std::make_shared<_State>()),
_M_storage(new _Res_type())
{ }
- 所有权
正如前面所说，当自行set_value时，会设置std::move(_M_promise->_M_storage)将_M_storage指向空间的所有权转让出去，对于set_value来说，就是转让给了_M_future结构的_Ptr_type字段。
当通过promise::get_future获得future时，会获得一个指向_State的指针。由于这个字段是shared_ptr，所以get_future之后返回的future对象和这个promise(以shared_ptr)形式共享这个future成员。
总起来说，它们的生命期维护关系为： _M_future是一个promise和future共同维护的shared_ptr，两个结构中的任意一个销毁都不会导致指向内容释放；结构中的_Ptr_type是一个unique_ptr，当_M_future析构的时候才会释放。
如何出现析构中的Broken promise
在确定了_M_storage是由于set_value而清空的之后，构造Broken promise的方法就很简单了：就是不调用set_value即可。
tsecer@harry: cat no_set_value_dest_promise.cpp
#include <future>
#include <stdio.h>
int main(int argc, const char *argv[])
{
std::promise<int> *pp = new std::promise<int>;
std::future<int> of = pp->get_future();
//pp->set_value(1234);
delete pp;
printf("future.get is %d\n", of.get());
return 0;
}
tsecer@harry: g++ -g no_set_value_dest_promise.cpp -lpthread
tsecer@harry: ./a.out
terminate called after throwing an instance of 'std::future_error'
what(): std::future_error: Broken promise
已放弃 (core dumped)
tsecer@harry: