Who is responsible for the shared state of futures and promises

Question

Who owns the shared state in futures and promises? In particular who is responsible for the construction and deletion of the shared state in these classes? Or is the shared state supposed to be reference counted? I am not able to get an answer by reading the docs for these on cppreference.

The way I was thinking about it the easiest thing to do would be to have the std::promise class be responsible for the creation of the shared state, but then hand it off to the std::future that is fetched from the std::promise for deletion when the future is destroyed. But then this approach can lead to dangling promise objects. So I am not sure how really the state is supposed to be shared between the two.

For example does the code below produce undefined behavior (since the shared state might be destroyed when the future is destroyed)?

auto prom = std::promise<void>{};
{
    auto fut = prom.get_future();
}
prom.set_value();

Further, the docs for std::promise::~promise on cppreference say "if the shared state is ready, releases it" which gets me to think that the shared state is not reference counted.

Ilanailangilang

@T.C. Some implementations of futures (not standard) I have seen don't have shared ownership.. And the standard (as far as cpprefernce) goes makes it seem like futures are responsible for releasing the shared state.. But I am not sure... – Ilanailangilang

It seems to behave exactly as shared_ptr<State> would have. Which implies reference counting – Dissemblance

Answer 1

When the std::future (or std::promise) is destroyed, it releases its shared state.

This rule states that when an asynchronous return object or an asynchronous provider is said to release its shared state, it gives up its reference to the shared state.

If that reference was the last one, the shared state is destroyed.

So yes, shared state seems to be reference counted and no, your code example does not produce UB since prom still holds a reference to the shared state.

Dissemblance

I read this line in the docs for the destructor for std::promise here en.cppreference.com/w/cpp/thread/promise/%7Epromise "if the shared state is ready, releases it." Why will the promise release the shared state in this case? Shouldn't it just be "if the shared state is ready, decrements the reference count for it" – Ilanailangilang

@Ilanailangilang One could ask the same question about the destructor for std::shared_ptr. Reference counting is an implementation detail. There is no normative occurrence of the term "reference count" in the standard. Cppref defines release as "the promise gives up its reference to the shared state. If this was the last such reference, the shared state is destroyed." – Indicate

@Ilanailangilang well this line fits exactly into what I've quoted from the standard: "releases shared state" means "gives up its reference to the shared state", and not "destroys it". – Dissemblance