C++ 多线程（future篇）

引言

       在前面介绍了启动线程，以及多线程下如何保证共享资源的竞争访问、线程同步这些。但是thread类无法访问从线程直接返回的值，如果要想获取线程的的执行结果，一般都是依靠全局或static变量，或是以实参传递的变量，然后结合互斥锁、条件变量，等待的线程去查验所等待的条件。假如某个线程按计划只等待一次，只要条件成立一次，它就不再理会条件变量了，条件变量不一定就是这种同步模式的最佳选择， 如果我们等待的条件是判定某份数据是否可用，C++ 标准库提供的std::future类模板更适合这种场景。

         C++ 标准库提供了std::future类模板来获取异步任务（即在单独的线程中启动的函数）的返回结果，并捕捉其所抛出的异常，这种获取结果的方式是异步的。如果线程需要等待某个特定的一次性事件发生，则会以恰当的方式取得一个future，它代表目标事件；接着这个该线程可以一边执行任务，一边在future上等待；同时，它以短暂的间隔反复查验目标事件是否已经发生。这个线程也可以转换运行模式，先不等目标事件发生，直接暂缓当前任务，而切换到别的任务，到了必要时，才回头等待futere准备就绪。future可能与数据关联，也可能未关联。一旦目标事件发生，其future即进入就绪状态，无法重置 。    

std::future

      C++标准库使用std::future为一次性事件建模，如果一个事件需要等待特定的一次性事件，那么这线程可以获取一个future对象来代表这个事件。异步调用往往不知道何时返回，但是如果异步调用的过程需要同步，或者说后一个异步调用需要使用前一个异步调用的结果。这个时候就要用到future。线程可以周期性的在这个future上等待一小段时间，检查future是否已经ready，如果没有，该线程可以先去做另一个任务，一旦future就绪，该future就无法复位（无法再次使用这个future等待这个事件），所以future代表的是一次性事件。       

         std::future是一个类模板(class template)，其对象存储未来的值，从一个异步调用的角度来说，future更像是执行函数的返回值，其模板参数就是期待返回的类型。

future类模板

template<typename ResultType>
class future
{
public:
  future() noexcept;
  future(future&&) noexcept;
  future& operator=(future&&) noexcept;
  ~future();
  
  future(future const&) = delete;
  future& operator=(future const&) = delete;
 
 
  bool valid() const noexcept;
  
  ResultType get();
  shared_future share();
 
  void wait();
 
  template<typename Rep,typename Period>
  future_status wait_for(
      std::chrono::duration const& relative_time);
 
  template<typename Clock,typename Duration>
  future_status wait_until(
      std::chrono::time_point const& absolute_time);
};

 

std::future的类型

 在库的头文件中声明了两种future，唯一future（std::future<>）和共享future（std::shared_future<>）这两个是参照std::unique_ptr和std::shared_ptr设立的，

• 唯一future（std::future<>）

仅有一个指向其关联事件的实例，

• 共享future（std::shared_future<>）

共享future（std::shared_future<>）可以有多个实例指向同一个关联事件，当事件就绪时，所有指向同一事件的std::shared_future实例会变成就绪。

 

总之，类模板 std::future 提供访问异步操作结果的机制：

1. 提供一个 std::future 对象给异步操作的创建者，一个有效的std::future对象通常是由某个 Provider 创建，你可以把 Provider 想象成一个异步任务的提供者，通常是：

• std::async() 函数
• std::promise::get_future()，get_future() 为 promise 类的成员函数
• std::packaged_task::get_future()，此时 get_future()为 packaged_task的成员函数

      由 std::future 默认构造函数创建的 future 对象不是有效的（除非当前非有效的 future 对象被 move 赋值另一个有效的 future 对象）

2. Provider 在某个线程中设置共享状态的值，与该共享状态相关联的 std::future 对象调用 get（通常在另外一个线程中） 获取该值，如果共享状态的标志不为 ready，则调用 std::future::get 会阻塞当前的调用者，直到 Provider 设置了共享状态的值（此时共享状态的标志变为 ready），std::future::get 返回异步任务的值或异常（如果发生了异常）。

std::async()

        因为std::thread没有提供直接回传结果的方法，函数模板std::async()应运而生。只要我们并不着急需要线程运算的结果，就可以用std::async()按异步方式启动任务。我们从std::async()函数处获得std::future对象(而非thread对象)，运行的函数一旦完成，其返回值就有该对象最后持有。若要用到这个值，只需要在future对象上调用get()，当前线程就会阻塞，以便future准备完毕并返回这个值.

std::async函数原型

template

future::type> async(launch policy, Fn&& fn, Args&&...args);

下面演示了用launch::async和launch::deferred两种不同的policy执行任务函数的差别，任务函数都是返回tid。从运行结果看得出来，使用async policy的方式是另起了一个thread运行的任务函数，因为其tid和调用线程的tid不同；相反，使用deferred policy的调用线程的tid和运行任务函数的tid是相等的，说明是在调用线程里调用的任务函数，而没有单独起一个线程去做。

#include 
#include 
#include 
 
using namespace std;
 
thread::id  test_async() {
	this_thread::sleep_for(chrono::milliseconds(500));
	return this_thread::get_id();
}
 
thread::id  test_async_deferred() {
	this_thread::sleep_for(chrono::milliseconds(500));
	return this_thread::get_id();
}
 
int main() {
	future ans = std::async(launch::async, test_async); //另起一个线程去运行test_async
	future ans_def = std::async(launch::deferred,test_async_deferred); //还没有运行test_async_deferred
 
	cout << "main thread id = " << this_thread::get_id() << endl;
	cout << "test_async thread id = " << ans.get() << endl;//如果test_async这时还未运行完，程序会阻塞在这里，直到test_async运行结束返回
	cout << "test_async_deferred thread id =  = " << ans_def.get() << endl;//这时候才去调用test_async_deferred，程序会阻塞在这里，直到test_async_deferred运行返回
 
	return 0;
}

 

 

std::packaged_task

         package_task<>是一个类模板，packaged_task类把一个可调用目标(函数、lambda表达式、bind表达式、函数对象)包装成一个对象，以便它可以被异步调用。packaged_task它连结了future对象与函数，package_task<>对象在执行任务时，会调用关联的函数，把返回值保存为future的内部数据，并令future准备就绪。

         package_task<>其模板参数是函数签名：比如，void()表示一个函数，不接收参数，也不接收返回值；int(string&,double*)代表某函数，它接收两个参数并返回int值。假设我们要构建packaged_task<>实例，那么，由于模板参数先行指定了函数签名，因此传入的函数必须与之相符。即它应该接收指定类型的参数，返回值也必须可以转换为指定类型。

1. 类模板packaged_task<>具有成员函数get_future，它返回future<>实例，该future的特化类型取决于函数签名所指定的返回值
2. packaged_task<>还具备函数调用操作符，它的参数取决于函数签名的参数列表。

packaged_task对象是可调用对象，我们可以直接调用，还可以将其包装在function对象内，当作线程函数传递给thread对象，也可以传递给需要可调用对象的函数。如果packaged_task作为函数对象而被调用，它就会通过函数调用操作符接收参数，并将其进一步传递给包装在内的任务函数，由其异步运行得出结果，并将其结果保存到future对象内部，再通过get_future()获取此对象。所以，为了在未来的适当时刻执行某项任务，我们可以将其包装在packaged_task对象内，取得对应的future之后，才把该对象传递给其他线程，由它触发任务执行。等到需要用到使用结果时，我们静候future准备就绪即可。

#include 
#include 
#include 
 
using namespace std;
 
int add(int a,int b) {
	cout <<"sub thread id: " << this_thread::get_id() << endl;
	return a + b;
}
 
int main() {
	cout << "main thread id: " << this_thread::get_id() << endl;
	packaged_task<int(int, int)> task_add(add);
	future<int> res = task_add.get_future();
 
	//另起线程调用 
	thread th(move(task_add),100,500);
	
	//也可以直接调用,和调用线程处于同一线程
    //task_add(100,500);
 
	cout << "res = " << res.get() << endl;
 
	th.join();
	return 0;
}

 

std::promise

有些任务无法以简单的函数调用表达出来，还有一些任务的执行结果可能来自多个部分的代码。promise给出了一种异步求值的方法，某个future对象与结果关联，能延后读出需要求取的值。配对的promise和future可实现下面的工作机制：等待数据的线程在future上阻塞，而提供数据的线程利用相配的promise设定关联的值，使future准备就绪。 

如下这段程序，创建一个 promise 对象，然后通过 promise 对象获取一个 future 对象，promise 在一个线程中设置了一个值，将 future 对象传递到另一个线程中去，而另一个线程中可以通过 std::future 来访问这个值（或者异常）。

#include 
#include 
#include 
 
using namespace std;
 
void add(int a, int b, promise<int>& p) {
	p.set_value(a + b);
}
 
void useResult(future<int>& f) {
	int val = f.get();//阻塞函数，直到收到相关联的std::promise对象传入的数据
	cout << "useResult: val = " << val << endl;
}
 
int main() {
	promise<int> prom;
	future<int> fut = prom.get_future();
 
	thread th(add,100,90,ref(prom));
	thread th2(useResult,ref(fut));
 
	th.join();
	th2.join();
	return 0;
}

       promise 提供了一个承诺（promise），表示在某个时间点一定会有一个值或一个异常会被设置。