C++11中std::shared_future的使用

女爷i 2023-07-02 15:24 6阅读 0赞

C++11中的std::shared\_future是个模板类。**与****std::future****类似，std::shared\_future****提供了一种访问异步操作结果的机制**；不同于std::future，std::shared\_future允许多个线程等待同一个共享状态；不同于std::future仅支持移动操作，std::shared\_future既支持移动操作也支持拷贝操作，而且多个shared\_future对象可以引用相同的共享状态。std::shared\_future还允许一旦共享状态就绪就可以多次检索共享状态下的值(A shared\_future object behaves like a future object, except that it can be copied, and that more than one shared\_future can share ownership over their end of a shared state. They also allow the value in the shared state to be retrieved multiple times once ready)。

std::shared\_future对象可以通过std::future对象隐式转换，也可以通过显示调用std::future::share显示转换，在这两种情况下，原std::future对象都将变得无效。

共享状态(shared state)的生存期至少要持续到与之关联的最后一个对象被销毁为止。与std::future不同，通过shared\_future::get检索的值不会释放共享对象的所有权。

std::future介绍参考：[https://blog.csdn.net/fengbingchun/article/details/104115489][https_blog.csdn.net_fengbingchun_article_details_104115489]

当你需要具有std::future的多个有效拷贝时会用到std::shared\_future；或者多个使用者使用std::future时也会用到std::shared\_future。

**Consider std::future, std::shared\_future to be like std::unique\_ptr, std::shared\_ptr**.

模板类std::shared\_future成员函数包括：

1. 构造函数：(1).不带参数的默认构造函数，此对象没有共享状态，因此它是无效的，但是它可以被赋予一个有效值；(2).拷贝构造：与const shared\_future& x具有相同的共享状态，并与之共享所有权；(3).支持移动构造。

2. 析构函数：销毁shared\_future对象，它是异常安全的。如果对象有效(即它可以访问共享状态)，则将其与对象接触关联；如果它是与共享状态关联的唯一对象，则共享对象本身也将被销毁。

3. get函数：(1).当共享状态就绪时，返回存储在共享状态中的值的引用(或抛出异常)。(2).如果共享状态尚未就绪(即provider提供者尚未设置其值或异常)，则该函数将阻塞调用的线程直到就绪。(3).当共享状态就绪后，则该函数将解除阻塞并返回(或抛出)，但与future::get不同，不会释放其共享状态，允许其它shared\_future对象也访问存储的值。(4).std::shared\_future<void>::get()不返回任何值，但仍等待共享状态就绪才返回或抛出。

4. operator=：(1).拷贝赋值：该对象与const shared\_future& rhs关联到相同的共享状态，并与之共享所有权；(2).移动赋值：该对象获取shared\_future&& rhs的共享状态，rhs不再有效。

5. valid函数：检查共享状态的有效性，返回当前的shared\_future对象是否与共享状态关联。

6. wait函数：(1).等待共享状态就绪。(2).如果共享状态尚未就绪(即提供者尚未设置其值或异常)，则该函数将阻塞调用的线程直到就绪。(3).当共享状态就绪后，则该函数将解除阻塞并void返回。

7. wait\_for函数：(1).等待共享状态在指定的时间内(time span)准备就绪。(2). 如果共享状态尚未就绪(即提供者尚未设置其值或异常)，则该函数将阻塞调用的线程直到就绪或已达到设置的时间。(3).此函数的返回值类型为枚举类future\_status。此枚举类有三种label：ready：共享状态已就绪；timeout：在指定的时间内未就绪；deferred：共享状态包含了一个延迟函数(deferred function)。(4).如果共享状态包含了一个延迟函数，则该函数不会阻塞，立即返回一个future\_status::deferred值。

8. wait\_until函数：(1). 等待共享状态在指定的时间点(time point)准备就绪。(2). 如果共享状态尚未就绪(即提供者尚未设置其值或异常)，则该函数将阻塞调用的线程直到就绪或已达到指定的时间点。(3).此函数的返回值类型为枚举类future\_status。(4).如果共享状态包含了一个延迟函数，则该函数不会阻塞，立即返回一个future\_status::deferred值。

详细用法见下面的测试代码，下面是从其他文章中copy的测试代码，详细内容介绍可以参考对应的reference：

#include "future.hpp"
    #include <iostream>
    #include <future>
    #include <chrono>
    #include <utility>
    #include <thread>
    
    namespace future_ {
    
    ///
    // reference: https://en.cppreference.com/w/cpp/thread/shared_future
    int test_shared_future_1()
    {
    	std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise;
    	// 通过std::future移动构造std::shared_future对象,t1_ready_promise和t2_ready_promise均会用到ready_future
    	std::shared_future<void> ready_future(ready_promise.get_future());
    
    	std::chrono::time_point<std::chrono::high_resolution_clock> start;
    
    	auto fun1 = [&, ready_future]() -> std::chrono::duration<double, std::milli> {
    			t1_ready_promise.set_value();
    			ready_future.wait(); // waits for the signal from main()
    			return std::chrono::high_resolution_clock::now() - start;
    		};
    
    	auto fun2 = [&, ready_future]() -> std::chrono::duration<double, std::milli> {
    		t2_ready_promise.set_value();
    		ready_future.wait(); // waits for the signal from main()
    		return std::chrono::high_resolution_clock::now() - start;
    	};
    
    	auto fut1 = t1_ready_promise.get_future();
    	auto fut2 = t2_ready_promise.get_future();
    
    	auto result1 = std::async(std::launch::async, fun1);
    	auto result2 = std::async(std::launch::async, fun2);
    
    	// wait for the threads to become ready
    	fut1.wait();
    	fut2.wait();
    
    	// the threads are ready, start the clock
    	start = std::chrono::high_resolution_clock::now();
    
    	// signal the threads to go
    	ready_promise.set_value();
    
    	std::cout << "Thread 1 received the signal " << result1.get().count() << " ms after start\n"
    		<< "Thread 2 received the signal " << result2.get().count() << " ms after start\n";
    
    	return 0;
    }
    
    ///
    // reference: https://en.cppreference.com/w/cpp/thread/shared_future/wait
    int fib(int n)
    {
    	if (n < 3) return 1;
    	else return fib(n - 1) + fib(n - 2);
    }
    
    int test_shared_future_2()
    {
    	// 将std::shared_future<int>调整为std::future<int>也是正确的
    	std::shared_future<int> f1 = std::async(std::launch::async, []() { return fib(20); });
    	std::shared_future<int> f2 = std::async(std::launch::async, []() { return fib(25); });
    
    	std::cout << "waiting...\n";
    	f1.wait();
    	f2.wait();
    
    	std::cout << "f1: " << f1.get() << '\n';
    	std::cout << "f2: " << f2.get() << '\n';
    
    	return 0;
    }
    
    ///
    // reference: https://en.cppreference.com/w/cpp/thread/shared_future/wait_for
    int test_shared_future_3()
    {
    	// 将std::shared_future<int>调整为std::future<int>也是正确的
    	std::shared_future<int> future = std::async(std::launch::async, [](){ 
            std::this_thread::sleep_for(std::chrono::seconds(3));
            return 8;  
        }); 
     
        std::cout << "waiting...\n";
        std::future_status status;
        do {
            status = future.wait_for(std::chrono::seconds(1));
            if (status == std::future_status::deferred) {
                std::cout << "deferred\n";
            } else if (status == std::future_status::timeout) {
                std::cout << "timeout\n";
            } else if (status == std::future_status::ready) {
                std::cout << "ready!\n";
            }
        } while (status != std::future_status::ready); 
     
        std::cout << "result is " << future.get() << '\n';
    
    	return 0;
    }
    
    } // namespace future_

**GitHub**：[https://github.com/fengbingchun/Messy\_Test][https_github.com_fengbingchun_Messy_Test]

[https_blog.csdn.net_fengbingchun_article_details_104115489]: https://blog.csdn.net/fengbingchun/article/details/104115489
[https_github.com_fengbingchun_Messy_Test]: https://github.com/fengbingchun/Messy_Test