C++11 使用 std::async创建异步程序

                               C++11 使用 std::async创建异步程序

最近用到异步线程挂起任务，而c++11提供了std::async方便快捷的创建线程，该函数使得我们的并发调用变得简单，优雅。参考了下面几个博客，对它们的内容进行了整合，谢谢作者的无私奉献，这里仅为自己做记录参考。

https://www.cnblogs.com/KunLunSu/p/8051542.html

https://blog.youkuaiyun.com/lijinqi1987/article/details/78909479

https://www.jianshu.com/p/58dea28d1a95

1.概念

c++11中增加了线程，使得我们可以非常方便的创建线程，它的基本用法是这样的：

Void fun(const std::string& thread_name, int thread_id);

std::string name1 =“线程1”;

std::string name2 = “线程2”;

std::thread thr1(fun, name1, 1);

std::thread thr2(fun, name2, 2);

thr1.join();

thr2.join();

但是线程毕竟是属于比较低层次的东西，有时候使用有些不便，比如我希望获取线程函数的返回结果的时候，我就不能直接通过 thread.join()得到结果，这时就必须定义一个变量，在线程函数中去给这个变量赋值，然后join,最后得到结果，这个过程是比较繁琐的。 c++11还提供了异步接口std::async，通过这个异步接口可以很方便的获取线程函数的执行结果。std::async会自动创建一个线程去调用线程函数，它返回一个std::future，这个future中存储了线程函数返回的结果，当我们需要线程函数的结果时，直接从future中获取，非常方便。而且，std::async给我们提供的便利可不仅仅是这一点，它首先解耦了线程的创建和执行，使得我们可以在需要的时候获取异步操作的结果；其次它还提供了线程的创建策略（比如可以通过延迟加载的方式去创建线程），使得我们可以以多种方式去创建线程。在介绍async具体用法以及为什么要用std::async代替线程的创建之前，先来说一说std::future、std::promise和 std::packaged_task。

2. std::future

2.1 基本介绍

std::future是一个非常有用也很有意思的东西，简单说std::future提供了一种访问异步操作结果的机制。从字面意思来理解，它表示未来，我觉得这个名字非常贴切，因为一个异步操作我们是不可能马上就获取操作结果的，只能在未来某个时候获取，但是我们可以以同步等待的方式来获取结果，可以通过查询future的状态（future_status）来获取异步操作的结果。future_status有三种状态：

·deferred：异步操作还没开始，异步函数在get时执行

·ready：异步操作已经完成，可以通过get获取结果了

·timeout：异步操作超时，返回结果数据还未准备好

//查询future的状态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);

2.2 get

该函数用来获取future结果，直接调用时会一直阻塞，等异步操作结束之后返回结果或异步任务抛出异常。

2.3 wait

等待异步操作完成，也就是异步结果数据就绪，没有返回值。数据就绪时，通过get函数，无等待即可获得数据。

2.4  wait_for和wait_until

wait_for、wait_until主要是用来进行超时等待的。wait_for等待指定时长，wait_until则等待到指定的时间点。返回值有3种状态：

ready - 数据已就绪，可以通过get获取了。

timeout - 超时，返回数据还未准备好。

deferred - 这个和std::async相关，表明无需wait，异步函数将在get时执行。

2.5 share

std::future允许move，但是不允许拷贝。如果用户确有这种需求，需要同时持有多个实例，怎么办呢? 这就是share发挥作用的时候了。 std::shared_future通过引用计数的方式实现了多实例共享同一状态，但有计数就伴随着同步开销(无锁的原子操作也是有开销的)，性能会稍有下降。因此C++11要求程序员显式调用该函数，以表明用户对由此带来的开销负责。std::shared_future允许move，允许拷贝，并且具有和std::future同样的成员函数，此处就不一一介绍了。当调用share后，std::future对象就不再和任何共享状态关联，其valid函数也会变为false。

2.6 valid

判断当前std::future实例是否有效。std::future主要是用来获取异步任务结果的，作为消费方出现，单独构建出来的实例没意义，因此其valid为false。当与其它生产方(Provider)通过共享状态关联后，valid才会变得有效，std::future才会发挥实际的作用。C++11中有下面几种Provider，从这些Provider可获得有效的std::future实例：

std::async

std::promise::get_future

std::packaged_task::get_future

2.7 例子

struct SResultInfo;
std::future <SResultInfo> m_futureOperateRes;
SResultInfo res;
If ( m_futureOperateRes.valid() )
{
	If ( m_futureOperateRes._Is_ready() )
	{
		res = m_futureOperateRes.get();
		If (  !res.empty() )
		{
			std::cout << “have result”<<std::endl;
		}
	}
}

3. std::promise

std::promise为获取线程函数中的某个值提供便利，在线程函数中给外面传进来的promise赋值，当线程函数执行完成之后就可以通过promis获取该值了，值得注意的是取值是间接的通过promise内部提供的future来获取的。它的基本用法：

std::promise<int> pr;

std::thread t( [ ](std::promise<int>&p){p.set_value_at_thread_exit(9);}, std::ref(pr) );

std::future<int> f = pr.get_future();

auto r = f.get();

4. std::packaged_task

std::packaged_task它包装了一个可调用的目标（如function, lambda expression, bind expression, or another function object）,以便异步调用，它和promise在某种程度上有点像，promise保存了一个共享状态的值，而packaged_task保存的是一 个函数。它的基本用法：

std::packaged_task<int()> task([](){ return 7; });

std::thread t1(std::ref(task));

std::future<int> f1 = task.get_future();

auto r1 = f1.get();

5. std::promise、std::packaged_task和std::future的关系

至此, 我们介绍了std::async相关的几个对象std::future、std::promise和std::packaged_task，其中 std::promise和std::packaged_task的结果最终都是通过其内部的future返回出来的，不知道读者有没有搞糊涂，为什么有 这么多东西出来，他们之间的关系到底是怎样的？且听我慢慢道来，std::future提供了一个访问异步操作结果的机制，它和线程是一个级别的属于低层次的对象，在它之上高一层的是std::packaged_task和std::promise，他们内部都有future以便访问异步操作结果，std::packaged_task包装的是一个异步操作，而std::promise包装的是一个值，都是为了方便异步操作的，因为有时我需要获取线程中的某个值，这时就用std::promise，而有时我需要获一个异步操作的返回值，这时就用std::packaged_task。那 std::promise和std::packaged_task之间又是什么关系呢？说他们没关系也关系，说他们有关系也有关系，都取决于你了，因为我可以将一个异步操作的结果保存到std::promise中。如果读者还没搞清楚他们的关系的话，我就用更通俗的话来解释一下。比如，一个小伙子给一个姑娘表白真心的时候也许会说：”我许诺会给你一个美好的未来“或者”我会努力奋斗为你创造一个美好的未来“。姑娘往往会说：”我等着“。现在我来将这三句话用c++11来翻译一下：

小伙子说：我许诺会给你一个美好的未来等于c++11中"std::promise a std::future"; 
小伙子说：我会努力奋斗为你创造一个美好的未来等于c++11中"std::packaged_task a future"; 
姑娘说：我等着等于c++11中"future.get()/wait()";

小伙子两句话的个中差异，自己琢磨一下，这点差异也是std::promise和std::packaged_task的差异。现实中的山盟海 誓靠不靠得住我不知道，但是c++11中的许诺和未来是一定可靠的，发起来了许诺就一定有未来。细想起来c++11标准的制定者选定的关键字真是贴切而有意思！

6. 为什么要用std::async代替线程的创建

6.1std::async的基本概念

        std::async又是干啥的，已经有了std::future、std::promise和std::packaged_task，够多的了，真的还要一个std::async来凑热闹吗?std::async表示很委屈：我不是来凑热闹的，我是来帮忙的。是的，std::async是为了让用户的少费点脑子的，它让这三个对象默契的工作。大概的工作过程是这样的：std::async先将异步操作用std::packaged_task包装起来，然后将异步操作的结果放到std::promise中，这个过程就是创造未来的过程。外面再通过future.get/wait来获取这个未来的结果，怎么样，std::async真的是来帮忙的吧，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，std::async已经帮你搞定一切了！

std::async()是一个接受回调(函数或函数对象或lambda表达式)作为参数的函数模板，并有可能异步执行它们。

std::async有两种模板重载形式:

// 不含执行策略
template <class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type> async(Fn&& f, Args&&... args);

// 含执行策略
template <class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& f, Args&&... args);

std::async返回一个std::future<T>，它存储由std::async()执行的函数对象返回的值。函数期望的参数可以作为函数指针参数后面的参数传递给std::async()。

两个重载形式的差别是一个含执行策略，而另一个不含。那么什么是执行策略呢？执行策略定义了async执行Fn(函数或可调用求对象)的方式，是一个枚举值：

enum class launch
{
    // 保证异步行为，Fn将在单独的线程中执行
    async = 1,
    // 当其它线程调用std::future::get时，
    // 将调用非异步形式, 即Fn在get函数内执行
    deferred = 2,
    // Fn的执行时机由std::async来决定
    any = async | deferred
};

不含加载策略的版本，使用的是std::launch::any，也即由std::async函数自行决定Fn的执行策略。那么C++11如何确定std::any下的具体执行策略呢，一种可能的办法是：优先使用async策略，如果创建线程失败，则使用deferred策略。它可以异步运行或不运行，这取决于系统的负载，但我们无法控制它。实际上这也是Clang的any实现方式。std::async的出现大大减轻了异步的工作量。使得一个异步调用可以像执行普通函数一样简单。

含加载策略的版本，std::async的具体原型如下

async(std::launch::async | std::launch::deferred, f, args...)，第一个参数是线程的创建策略，有两种策略，默认的策略是立即创建线程：

std::launch::async：在调用async就开始创建线程。

std::launch::deferred：延迟加载方式创建线程。调用async时不创建线程，直到调用了future的get或者wait时才创建线程。

第二个参数是线程函数，第三个参数是线程函数的参数。

6.2 实例1之基本调用法

#include <iostream> // std::cout, std::endl
#include <future>   // std::async, std::future
#include <chrono>   // seconds
using namespace std::chrono;
void main()
{
	std::future<int> f1 = std::async(std::launch::async, []() {
		return 8;
	});
	std::cout << f1.get() << std::endl;//output: 8

	std::future<void> f2 = std::async(std::launch::async, []() {
		std::cout << 88 << std::endl;
		//return 88;
	});
	f2.wait(); //output: 88

	std::future<int> future = std::async(std::launch::async, []() {
		std::this_thread::sleep_for(std::chrono::seconds(30));
		return 888;
	});

	std::cout << "waiting...\n";
	std::future_status status;
	std::this_thread::sleep_for(seconds(3));

	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';
	std::system("pause");
}

6.3 实例2std::async应用

 

假设我们必须从数据库和文件系统里里获取一些数据（字符串），然后需要合并字符串并打印。

在单线程中，我们这样做：

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
 
using namespace std::chrono;
std::string fetchDataFromDB(std::string recvData) 
{
  //确保函数要5秒才能执行完成
  std::this_thread::sleep_for(seconds(5));

  //处理创建数据库连接、获取数据等事情
  return "DB_" + recvData;
}
 
std::string fetchDataFromFile(std::string recvData) 
{
  //确保函数要5秒才能执行完成
  std::this_thread::sleep_for(seconds(5));
 
  //处理获取文件数据
  return "File_" + recvData;
}
 
int main()
{
  //获取开始时间
  system_clock::time_point start = system_clock::now();
 
  //从数据库获取数据
  std::string dbData = fetchDataFromDB("Data");
 
  //从文件获取数据
  std::string fileData = fetchDataFromFile("Data");
 
  //获取结束时间
  auto end = system_clock::now();
 
  auto diff = duration_cast<std::chrono::seconds>(end - start).count();
  std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;
 
  //组装数据
  std::string data = dbData +  " :: " + fileData;
 
  //输出组装的数据
  std::cout << "Data = " << data << std::endl;
 
  return 0;
}

输出：
Total Time Taken  = 10 Seconds
Data = DB_Data :: File_Data

由于函数 fetchDataFromDB( ) 和 fetchDataFromFile( )各自在单独的线程中运行5秒，所以，总共耗时10秒。

既然从数据库和文件系统中获取数据是独立的并且都要耗时，那我们可以并行地运行他们。一种方式是创建一个新的线程传递一个promise作为线程函数的参数，并在调用线程中从关联的std::future对象获取数据；另一种方式就是使用std::async方式。

 

 

使用函数指针调用std::async作为回调

修改上面的代码，并使用std::async异步调用fetchDataFromDB( )

std::future<std::string>resultFromDB = std::async(std::launch::async, fetchDataFromDB, "Data");

std::string dbData = resultDromDB.get()

std::async()做如下的事情：

• 自动创建一个线程(或从内部线程池中挑选)和一个promise对象。
• ·然后将std::promise对象传递给线程函数，并返回相关的std::future对象
• ·当我们传递参数的函数退出时，它的值将被设置在这个promise对象中，所以最终的返回值将在std::future对象中可用

 

现在改变上面的例子，使用std::async异步地从数据库中获取数据

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>
using namespace std::chrono;
std::string fetchDataFromDB(std::string recvData) 
{
  //确保函数要5秒才能执行完成
  std::this_thread::sleep_for(seconds(5));
  //处理创建数据库连接、获取数据等事情
  return "DB_" + recvData;
}

std::string fetchDataFromFile(std::string recvData) 
{
  //确保函数要5秒才能执行完成
  std::this_thread::sleep_for(seconds(5));
  //处理获取文件数据
  return "File_" + recvData;
}

int main() 
{
  //获取开始时间
  system_clock::time_point start = system_clock::now();
    std::future<std::string> resultFromDB = std::async(std::launch::async, 
fetchDataFromDB, "Data");

    std::future<std::string> resultFromFile = std::async(std::launch::async, fetchDataFromFile, "Data");

  //从文件获取数据
  //数据在future<std::string>对象中可获取之前，将一直阻塞
  std::string fileData = resultFromFile.get();

  //从DB获取数据
  //数据在future<std::string>对象中可获取之前，将一直阻塞
  std::string dbData = resultFromDB.get();

  //获取结束时间
  auto end = system_clock::now();

  auto diff = duration_cast<std::chrono::seconds>(end - start).count();
  std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;
  
  //组装数据
  std::string data = dbData +  " :: " + fileData;

  //输出组装的数据
  std::cout << "Data = " << data << std::endl;
  return 0;
}

输出：
Total Time taken= 5Seconds
Data = DB_Data :: File_Data
只使用了5秒

用Function对象作为回调调用std::async

/*Function Object*/

struct DataFetcher 
{
    std::string operator ( )(std::string recvdData)
    {
        //确保函数要5秒才能执行完成
        std::this_thread::sleep_for(seconds(5));

        //处理获取文件数据
        return "File_" + recvdData;

    }

};

//用函数对象调用std::async
std::future<std::string> fileResult = std::async(DataFetcher(), "Data");

 

用lambda函数作为回调调用std::async

std::future<std::string> resultFromDB = std::async([ ](std::string recvdData) {

  std::this_thread::sleep_for(seconds(5));

  //处理创建数据库连接、获取数据等事情

  return "DB_" + recvdData;

}, "Data");

虽然修改上面的代码，并使用std::async异步调用fetchDataFromDB()和fetchDataFromFile(),但是在future<std::string>对象中可获取之前，将一直阻塞。这样若是在系统中就不合理，所以最好使用判断条件来确定是否已经完成，然后获取结果。

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>

using namespace std::chrono;

std::string fetchDataFromDB(std::string recvData)
{
	//确保函数要5秒才能执行完成
	std::this_thread::sleep_for(seconds(5));

	//处理创建数据库连接、获取数据等事情
	return "DB_" + recvData;
}

std::string fetchDataFromFile(std::string recvData)
{
	//确保函数要5秒才能执行完成
	std::this_thread::sleep_for(seconds(5));

	//处理获取文件数据
	return "File_" + recvData;
}

/*
int main()
{
	bool bStop = false;
	//获取开始时间
	system_clock::time_point start = system_clock::now();

	std::future<std::string> resultFromDB = std::async(std::launch::async, fetchDataFromDB, "Data");

	std::future<std::string> resultFromFile = std::async(std::launch::async, fetchDataFromFile, "Data");

	std::string fileData = "";
	std::string dbData = "";
	int iCount = 0;
	do
	{
		std::cout << iCount << std::endl;
		//从文件获取数据
		//数据在future<std::string>对象中可获取之前，将一直阻塞
		fileData = resultFromFile.get();

		//从DB获取数据
		//数据在future<std::string>对象中可获取之前，将一直阻塞
		dbData = resultFromDB.get();

		iCount++;
	} while (fileData.empty() && dbData.empty());


	//获取结束时间
	auto end = system_clock::now();

	auto diff = duration_cast<std::chrono::seconds>(end - start).count();
	std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;

	//组装数据
	std::string data = dbData + " :: " + fileData;

	//输出组装的数据
	std::cout << "Data = " << data << std::endl;

	std::system("pause");
	return 0;
}
*/


int main()
{
	bool bStop = false;
	//获取开始时间
	system_clock::time_point start = system_clock::now();

	std::future<std::string> resultFromDB = std::async(std::launch::async, fetchDataFromDB, "Data");

	std::future<std::string> resultFromFile = std::async(std::launch::async, fetchDataFromFile, "Data");

	std::string fileData = "";
	std::string dbData = "";
	int iCount = 0;
	bool bRes1 = false;
	bool bRes2 = false;
	do
	{
		std::cout << iCount << std::endl;
		//从文件获取数据
		if (resultFromFile.valid())
		{
			if (resultFromFile._Is_ready())
			{
				fileData = resultFromFile.get();

				if (!fileData.empty())
				{
					bRes1 = true;
				}
			}
		}

		//从DB获取数据
		if (resultFromDB.valid())
		{
			if (resultFromDB._Is_ready())
			{
				dbData = resultFromDB.get();

				if (!dbData.empty())
				{
					bRes2 = true;
				}
			}
		}

		iCount++;
	} while (!(bRes1 == true && bRes2 == true));


	//获取结束时间
	auto end = system_clock::now();

	auto diff = duration_cast<std::chrono::seconds>(end - start).count();
	std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;

	//组装数据
	std::string data = dbData + " :: " + fileData;

	//输出组装的数据
	std::cout << "Data = " << data << std::endl;

	std::system("pause");
	return 0;
}

6.4 实例3之std::async和std::deferred

#include <iostream> // std::cout, std::endl
#include <future>   // std::async, std::future
#include <chrono>   // seconds
using namespace std::chrono;

int main()
{
	auto print = [](char c)
	{
		for (int i = 0; i < 10; i++)
		{
			std::cout << c;
			std::cout.flush();
			std::this_thread::sleep_for(milliseconds(1));
		}
	};

	// 不同launch策略的效果
	std::launch policies[] = { std::launch::async, std::launch::deferred };
	const char *names[] = { "async   ", "deferred" };
	for (int i = 0; i < sizeof(policies) / sizeof(policies[0]); i++)
	{
		std::cout << names[i] << ": ";
		std::cout.flush();
		auto f1 = std::async(policies[i], print, '+');
		auto f2 = std::async(policies[i], print, '-');
		f1.get();
		f2.get();
		std::cout << std::endl;
	}

	std::system("pause");
	return 0;
}

 

6.5 实例4之std::async应用lamda回调

#include <iostream> // std::cout, std::endl
#include <future>   // std::async, std::future
#include "opencv.hpp"

struct TargetMatchBasedOnApperanceInfo
{
	cv::Mat Img;
	cv::Rect rect;
};	//参数输入结构体
struct CaptureResultInfo
{
	int ilabel;
	float fConf;
};				//结果输出结构体
class CAppearanceAnalysis	//异步处理函数
{
public:
	void Do(const TargetMatchBasedOnApperanceInfo& input, std::vector<CaptureResultInfo>& res);
};


TargetMatchBasedOnApperanceInfo* m_pApperanceInfo{ nullptr };
std::future<std::vector<CaptureResultInfo>> m_futureAppearanceReId;
CAppearanceAnalysis* m_pAppearanceAnalysis{ nullptr };


bool bASync = true;
bool AppearanceReId(bool bASync /*= false*/, std::vector<CaptureResultInfo>& res)
{
	res.clear();

	if (bASync)
	{
		if (m_futureAppearanceReId.valid())
		{
			if (m_futureAppearanceReId._Is_ready())
			{
				res = m_futureAppearanceReId.get();
				if (! res.empty())
				{
					std::cout << "get result successfully!!!" << std::endl;
					return true;
				}
			}
			else
			{
				return false;
			}
		}


		if (m_pApperanceInfo == nullptr)
		{
			m_pApperanceInfo = new TargetMatchBasedOnApperanceInfo;
			//对m_pApperanceInfo的参数进行赋值
		}
		else
		{
			//对m_pApperanceInfo的参数进行赋值
		}

		m_futureAppearanceReId = std::async(std::launch::async, [](const TargetMatchBasedOnApperanceInfo& input) {
			std::vector<CaptureResultInfo> res;
			m_pAppearanceAnalysis->Do(input, res);
			return res;
		}, *m_pApperanceInfo);
	}
	else
	{
		//同步线程做
		return true;
	}

	return false;
}

void main()
{
	m_pAppearanceAnalysis = new CAppearanceAnalysis();
	std::vector<CaptureResultInfo> res;
	bool bASync = true;


	bool bOk = false;

	do
	{
		bOk = AppearanceReId(bASync, res);
	}while(bOk == true);


	std::system("pause");
}