C++异步编程(std::async, std::future, std::packaged_task, std::promise)

墨蓝 2022-09-09 00:24 126阅读 0赞

引用自文章：https://cloud.tencent.com/developer/article/1584075

**std::async**  
是一个函数模板，会**启动一个异步任务，最终返回一个std::future对象**。在之前我们都是通过thread去创建一个子线程，但是如果我们要得到这个子线程所返回的结果，那么可能就需要用全局变量或者引用的方法来得到结果，这样或多或少都会不太方便，那么async这个函数就可以将得到的结果保存在future中，然后通过future来获取想要得到的结果。async比起thread来说可以对线程的创建又有了更好的控制，比如可以延迟创建。下面先介绍一下std::future, std::packaged\_task, std::promise。

**std::future**  
std::future是一个类模板，提供了一个访问异步操作的结果的机制。我们可以通过future\_status去查询future的三种状态，分别是deferred(还未执行)，ready(已经完成)，timeout(执行超时)，所以我们可以通过这个去查询异步操作的状态。future提供了一些函数比如get(),wait(),wait\_for()，一般用**get()来获取future所得到的结果**，如果异步操作还没有结束，那么会在此**等待异步操作的结束**，并获取返回的结果。**wait()只是在此等待异步操作的结束，并不能获得返回结果。wait\_for()超时等待返回结果**。

// future<获取的结果类型> 变量名
    // async(函数名, 参数)
    std::future<int> fu = std::async(fun, 1);    
    std::cout << fu.get() << std::endl;

**std::packaged\_task**  
std::packaged\_task是一个类模板，顾名思义是用来打包的，将一个可调用对象封装起来，然后可以将其的返回值传给future。std::packaged\_task<函数返回类型(参数类型)> 变量名(函数名)。下面展示一下std::packaged\_task()的简单用法，也可以将函数换成lambda表达式。

#include <iostream>
    #include <future>
    #include <thread>
    using namespace std;
    
    // 函数，返回工作线程id
    thread::id fun() {
        
    	cout << "fun::id : " << this_thread::get_id() << endl;
    	return this_thread::get_id();	// 返回线程id
    }
    
    
    int main()
    {
        
    	packaged_task<thread::id(void)> pt(fun);         // 将函数打包起来
    	future<thread::id> fu = pt.get_future();        // 并将结果返回给future
    
    	thread t(ref(pt));
    	auto res = fu.get();
    	t.join();
    
    	cout << "main : " << res << std::endl;
    
    	/*
    		输出：
    		fun::id : 4816
    		main : 4816
    	*/
    	return 0;
    }

**std::promise**  
std::promise是一个类模板，它的作用是在不同的线程中实现数据的同步，与future结合使用，也间接实现了future在不同线程间的同步。

#include <iostream>
    #include <future>
    #include <thread>
    using namespace std;
    
    // 函数，返回工作线程id
    thread::id fun(std::promise<thread::id>& p) {
        
    	auto this_id = this_thread::get_id();
    	cout << "fun::id : " << this_id << endl;
    	p.set_value(this_id);	// 原子地存储 value 到共享状态，并令状态就绪。
    	return this_id;	// 返回线程id
    }
    
    
    int main()
    {
        
    	std::promise<thread::id> p;						 // 线程同步
    	std::future<thread::id> fu = p.get_future();     // 并将结果返回给future
    
    	std::thread t(fun, std::ref(p));
    	auto res = fu.get();          // 当promise还没有值的时候在此等待
    	t.join();
    
    	cout << "main : " << res << std::endl;
    	/*
    		输出：
    		fun::id : 4816
    		main : 4816
    	*/
    	return 0;
    }

promise还有一个函数是set\_value\_at\_thread\_exit()这个翻译一下就可以直到它的作用是当在这个线程执行结束的时候才会将future的状态设置为ready，而set\_value()则直接将future的状态设置为ready。需要注意的是在使用的过程中不能多次set\_value()，也不能多次get\_future()和多次get()，因为一个promise对象只能和一个对象相关联，否则就会抛出异常。

std::async  
其实这个函数是对上面的对象的一个整合，async先将可调用对象封装起来，然后将其运行结果返回到promise中，这个过程就是一个面向future的一个过程，最终通过future.get()来得到结果。它的实现方法有两种，一种是std::launch::async，这个是直接创建线程，另一种是std::launch::deferred，这个是延迟创建线程(当遇到future.get或者future.wait的时候才会创建线程)，这两个参数是std::async的第一个参数，如果没有使用这个两个参数，也就是第一个参数为空的话，那么第一个参数默认为std::launch::async | std::launch::deferred，这个就不可控了，由操作系统根据当时的运行环境来确定是当前创建线程还是延迟创建线程。那么std::async的第二个参数就是可调用对象的名称，第三个参数就是可调用对象的参数。

#include <iostream>
    #include <future>
    #include <thread>
    using namespace std;
    
    // 函数，返回工作线程id
    thread::id fun() {
        
    	auto this_id = this_thread::get_id();
    	cout << "fun::id : " << this_id << endl;
    
    	return this_id;	// 返回线程id
    }
    
    
    
    int main()
    {
        
    	// std::launch::deferred 当执行到fu.get才开始创建线程
    	std::future<thread::id> fu = async(std::launch::deferred, fun);
    
    	auto res = fu.get();          // 当promise还没有值的时候在此等待
    
    	cout << "main : " << res << std::endl;
    	/*
    		输出：
    		fun::id : 16680
    		main : 16680
    	*/
    	return 0;
    }