引言

遇到这个问题以后第一次没有得到解答 随后经测试和查阅资料知道了它的由来 同时列出三种导致抛出future_error的原因 希望能有相同问题的朋友能得到帮助

什么是future_error

这是官网对于这个类型的解释

The class std::future_error defines an exception object that is thrown on failure by the functions in the thread library that deal with asynchronous execution and shared states

我们可以看到它是在处理异步程序和shared 状态失败的时候会被抛出.而且它本身是一个各个系统上实现不一致的东西,即ub

我们来看看官网的演示demo

#include <future>
#include <iostream>

int main()
{
    std::future<int> empty;
    try {
        int n = empty.get(); // The behavior is undefined, but
                             // some implementations throw std::future_error
    } catch (const std::future_error& e) {
        std::cout << "Caught a future_error with code \"" << e.code()
                  << "\"\nMessage: \"" << e.what() << "\"\n";
    }
}

我们可以看到在future的状态不是ready的时候我们进行get操作是ub,但是一些实现则会抛错,那么还有哪些情况会抛错呢

我们来简单的看看future的实现

      void
      set_value(const _Res& __r)
      { _M_future->_M_set_result(_State::__setter(this, __r)); }

      void
      set_value(_Res&& __r)
      { _M_future->_M_set_result(_State::__setter(this, std::move(__r))); }

      void
      set_exception(exception_ptr __p)
      { _M_future->_M_set_result(_State::__setter(__p, this)); }

        --------------------------------------------------------------------

      _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
      {
    bool __did_set = false;
        // all calls to this function are serialized,
        // side-effects of invoking __res only happen once
    call_once(_M_once, &_State_baseV2::_M_do_set, this,
          std::__addressof(__res), std::__addressof(__did_set));
    if (__did_set)
      // Use release MO to synchronize with observers of the ready state.
      _M_status._M_store_notify_all(_Status::__ready,
                    memory_order_release);
    else if (!__ignore_failure)
          __throw_future_error(int(future_errc::promise_already_satisfied));
      }

我们可以看到在设置值的过程中函数都调用了M_set_result这个函数,而这个函数中使用了call_once,这个函数第一个参数是once_flag类型的,作用是这个函数在这段代码中代码仅调用一次,之后调用失败,

      void
      _M_do_set(function<_Ptr_type()>* __f, bool* __did_set)
      {
        _Ptr_type __res = (*__f)();
        // Notify the caller that we did try to set; if we do not throw an
        // exception, the caller will be aware that it did set (e.g., see
        // _M_set_result).
    *__did_set = true;
        _M_result.swap(__res); // nothrow
      }

我们可以看到如果成功执行了call_once,也就是第一次调用call_once,就会使dis_set为true,从而进入第一个判断条件,但是第后面调用的时候就会进入第二个判断条件,直接抛出一个future_error的错误,这也是一个抛错的时机 下面是一个demo

void test(std::promise<int>& para){
    para.set_value(10);
    para.set_value(20);
    return;
}

int main(){
    std::promise<int> pro;
    std::future<int> T = pro.get_future();
    std::thread fun(test, std::ref(pro));
    fun.join();
    cout << T.get() << endl;
    return 0;
}

terminate called after throwing an instance of 'std::future_error'
  what():  std::future_error: Promise already satisfied
[1]    12731 abort      ./a.out

随着两次的set_value 当然会抛错了.

再来看一种情况

template<typename _Tp>
  static void
  _S_check(const shared_ptr<_Tp>& __p)
  {
    if (!static_cast<bool>(__p))
      __throw_future_error((int)future_errc::no_state);
  }

我们可以看到这个函数中也会抛出future_error 且判断条件只有一句,很巧,找到了另一个成员函数

bool
valid() const noexcept { return static_cast<bool>(_M_state); }

在官网上我们找到了这样一段解释

Checks if the future refers to a shared state.
This is the case only for futures that were not default-constructed or moved from (i.e. returned by std::promise::get_future(), std::packaged_task::get_future() or std::async()) until the first time get() or share() is called.
The behavior is undefined if any member function other than the destructor, the move-assignment operator, or valid is called on a future that does not refer to shared state (although implementations are encouraged to throw std::future_error indicating no_state in this case). It is valid to move from a future object for which valid() is false

检测future是否指向共享状态
这仅适用于为非默认构造的或是在第一次执行get或者share之前未移动的future(返回 std::promise::get_future(), std::packaged_task::get_future() 或者std::async()算是移动),
如果在未引用共享状态的将来调用除析构函数，移动运算符或valid以外的任何成员函数，则该行为未定义(),尽管在这种情况下有些实现会鼓励抛出一个future_error来指示no_state,从valid()返回为false的对象移动的对象是有效的.

下面一个简单的小demo来模拟这种情况

void test(std::promise<int>& para){
    para.set_value(10);
    //para.set_value(20);
    return;
}

int main(){
    std::promise<int> pro;
    std::future<int> T = pro.get_future();
    std::thread fun(test, std::ref(pro));
    fun.join();
    cout << T.get() << endl;
    auto Error_T = pro.get_future();
    return 0;
}

10
terminate called after throwing an instance of 'std::future_error'
  what():  std::future_error: Future already retrieved
[1]    14518 abort      ./a.out

在get后执行了get_future 抛出了错误

参考
https://en.cppreference.com/w/cpp/thread/future_error