C++多线程packaged_task

2020-12-20

类模板声明如下：

template class packaged_task;

template<class R,class …Args>

class packaged_task<R(Args…)>;

类模板std::package_task 包含所有可调用对象（function,lambda expression,bind expression or another function object，所以它能够异步执行。它返回一个包含处理后的结果或者是异常的状态的std::future对象。std::packaged_task是一个多态，支持分配器的容器，它所包含的可调用目标可能被分配在堆中或者提供的分配器中。

std::packaged_task构造函数：

构造一个续保的packaged_task对象，其中copy constructor已经被禁用，看一下说明：

\1. 默认无参构造函数

\2. 显示构造一个packaged_task对象，其任务由参数f指定。

\3. 显示构造函数，使用提供的分配器用来保存任务

\4. copy constructor被禁用

\5. move constructo

std::packaged_task 将copy assignment 也给禁用了，只能同过移动语义为将一个packaged_task对象的资源移动给另外一个packaged_task对象。如果直接使用 “=”会编译出错。即如下代码所示

1 2	std::packaged_task<int(int)> bar([](int x){return x*10;}); auto barx = std::move(bar);

std::packaged_task中的valid函数用来检查对象是否含有可共享的状态。

std::packaged_task中的swap函数用来交换当前对象与另外一个对象的状态

std::packaged_task的get_future()返回一个future对象

**std::packaged_task::operator()(Args… args)**的功能是调用packaged_task对象所包装的可调用对象并将参数args传入到其所包装的可调用对象中。调用成功，返回值保存在packaged_task的共享状态中，调用失败，异常会被保存在共享状态中，但是两者都会是共享状态变为ready. 因此其他等待该共享状态的线程可以获取共享状态的值或者异常并继续执行下去.

std::packaged_task::make_ready_at_thread_exit(ArgTypes…args); 的功能是调用packaged_task对象所包装的可调用对象并将参数args传入到其所包装的可调用对象中。与**std::packaged_task::operator()(Args… args)**类似，但是只有在线程退出的时候，才将共享状态设置为ready.

*std:;packaged_task::reset()**重置 packagedtask 的共享状态，但是保留之前的被包装的任务。注意：在使用reset的时候，不能使用get_future两次，会出问题。*

示例代码如下：

#include <iostream>
#include <future>
#include <thread>
#include <chrono>
int foo(int a,int b){
  std::this_thread::sleep_for(std::chrono::microseconds(std::abs(b-a)));
  std::cout << "thread " << std::this_thread::get_id()<<" sleep for " << std::abs(b-a) << " microseconds" << std::endl;
  return std::abs(b-a);
}
int main(int argc,char* argv[])
{
  //construct a packaged_task
  std::packaged_task<int(int,int)> fo(foo);

  //if fo is valid and exchange foox with fo
  std::packaged_task<int(int,int)> foox;
  if (fo.valid()){
    fo.swap(foox);
  }
  //get future
  std::future<int> f = foox.get_future();
  //create a thread
  std::thread(std::move(foox),20,30).detach();

  int val = f.get();
  std::cout << val<< std::endl;
  //move
  std::packaged_task<int(int)> bar([](int x){return x*10;});
  auto barx = std::move(bar);

  std::future<int> f2 = barx.get_future();
  barx(100);
  std::cout << f2.get()<< std::endl;
  //reset
  barx.reset();
  f2 = barx.get_future();
  std::thread(std::move(barx),10).join();
  std::cout <<f2.get()<< std::endl;
  return 0;
}