C++ std::future

std::future是用来接收一个线程的执行结果的，并且是一次性的。

共享状态shared state

future可以关联一个共享状态，共享状态是用来储存要执行结果的。这个结果是async、promise、packaged_task设置的，且这个结果只能设置一次。

创建future

创建future有四种方式

1.  直接构造函数创建，这种创建的future没用共享状态。

   std::future future;

2. 调用std::async，返回一个future对象，返回的future有共享状态。std::async是执行一个异步任务，这个任务会放到线程池中的线程执行，并通过future返回执行结果。通常异步任务优先考虑使用std::async，而不是std::thread。

   auto future = std::async([]{
       return DataType{5};
   });
   std::cout <<"future is Valid:" << future.valid() 
             << " , async Result:" << future.get().n << std::endl;

3. 创建std::promise，然后调用std::promise::get_future获取future对象，返回的future有共享状态。promise可以设置一个值传递给future，也可以设置一个异常传递给future。promise的set_value和set_exception 只能调用一次，调第二次时会抛出异常。如果promise在析构前都未设置结果，调用future::get获取结果会抛出异常。

       {
           std::cout << "------------- promise -----------------\n";
           std::promise promise;
           promise.set_value({5});
           // promise.set_value({6}); //set_value只能调用一次，再次调用会抛出异常
           auto future = promise.get_future();
           // auto future2 = promise.get_future(); //get_future只能调用一次，再次调用会抛出异常
           std::cout <<"future is Valid:" << future.valid() << " , async Result:" << future.get().n << std::endl;
       }
       {
           std::cout << "------------- promise exception -----------------\n";
           std::promise promise;
   
           try {
               throw std::runtime_error("error");
           } catch (...) {
               // 如果调用了 promise.set_value ，则不能调用 promise.set_exception ，
               // 否则 promise.set_exception 会抛出异常
               promise.set_exception(std::current_exception());
           }
           auto future = promise.get_future();
           try {
               auto data =  future.get();
               std::cout <<"future is Valid:" << future.valid() << " , async Result:" << data.n << std::endl;
           } catch (const std::exception& e) {
               std::cout << e.what() << std::endl;
           }
       }
   

4. 创建std::packaged_task，然后调用get_futurestd::packaged_task::get_future获取future对象，返回的future有共享状态。

   std::cout << "------------- packaged -----------------\n";
   std::packaged_task task([](int a) {
       return DataType{a};
   });
   auto future = task.get_future();
   // auto future2 = task.get_future(); //get_future只能调用一次，再次调用会抛出异常
   task(5);
   std::cout <<"future is Valid:" << future.valid()
             << " , async Result:" << future.get().n << std::endl;

future状态

可以通过函数future::valid可以判断future是否有共享状态。如果有共享状态可以进一步通过函数future::wait_for(0s)来判读结果是否已经设置。wait_for有三个返回值：

1. future_status::deferred 表示结果还未设置
2. future_status::ready 表示结果已经设置
3. future_status::timeout 表示超时

获取结果

通过future::get函数可以获取future的结果，调用get函数需要注意以下几点：

1.  只有有共享状态的future才能获取结果，如果没有共享状态会抛出异常。
2. 如果获取数据时future结果已经设置好，则会立即返回。
3. 如果future状态还未设置好，则会挂起线程一直等待，直到结果被设置。如果相应async、promise、packaged_task到结束都一直未设置状态，则会抛出异常。
4. get函数只能调用一次，调用完成后则会删除共享状态，再次调用get函数，会因为没有共享状态而抛出异常。

也可以调用wait，wait_for, wait_until等带结果被设置。

多线程调用future

获取future结果时，可以先判断future是否有共享状态，然后再调用get函数获取结果，代码如下：

        if (future.valid())
        {
            future.get();
        }

上面代码在单线程调用没有问题，如果在线程同时调用则会有问题，多个线程会同时判断future有共享状态，因此同时有多个线程调用get函数，而get函数只能被调用一次，从而引发异常。

可以通过加锁解决这个问题，但这并不是好的方法。更优雅的方法是通过future::share函数，为每个线程创建一个std::shared_future。future调用完share将不再拥有共享状态，如下：

如果future本身没有共享状态，调用share会生成一个没有共享状态的shared_future。

shared_future调用get函数时并不会清楚共享状态，所以shared_future可以多次调用get函数。

示例代码：

    std::promise promise;
    auto future = promise.get_future();
    auto shadedFuture = future.share();
    std::cout << "future is valid: " << future.valid() << std::endl;
    
    std::thread threads[4];
    for (int i = 0; i < 4; ++i)
    {
        threads[i] = std::thread([future=shadedFuture](int i){
            std::cout << std::to_string(i) + ", future is Valid:" + std::to_string(future.valid())
                             + " , async Result:" + std::to_string(future.get().n) + "\n";
        }, i);
    }
    
    std::this_thread::sleep_for(std::chrono::milliseconds{100});
    promise.set_value({5});
    
    for (int i = 0; i < 4; ++i)
    {
        threads[i].join();
    }
    std::cout << std::endl;

future析构阻塞

当future是由async创建的，且future/shared_future是最后一个指向共享状态的future，如果async还在执行，则future在析构时会阻塞当前线程，等待async执行完成。