cpp多线程编程demo3

cpp多线程编程demo3

future promise

std::future对象可以和async，std::packaged_task，std::promise一起使用。这篇文章集中讨论std::future和std::promise。

我们经常会遇到需要得到线程返回结果的情况，现在的问题是我们如何实现。

举个例子：假设在程序中，我们创建了一个压缩给定文件夹的线程，并且我们希望该线程能够返回新的zip文件的名称和大小。

有两种实现方式：

1、老方法：使用指针在线程间共享数据

• 传递一个指针到新的线程中，该线程将在其中设置数据。主线程则使用条件变量等待。当新线程设置数据并通知条件变量时，主线程将唤醒并从该指针处获取数据。
• 为了实现这一简单功能，我们使用了一个条件变量、一个mutex锁和一个指针，来实现捕获返回值。
• 如果我们想要该线程在不同的时间点返回3个不同的值，问题会变得更加复杂，有没有一种简单的方法来从线程处获取返回值呢？

答案是使用std::future

2、c++11的方法：使用std::future 和 std::promise

• std::future是一个类模板(class template)，其对象存储未来的值，
• 到底什么是未来的值呢？
• 事实上，一个std::future对象在内部存储一个将来会被赋值的值，并提供了一个访问该值的机制，通过get()成员函数实现。但如果有人试图在get()函数可用之前通过它来访问相关的值，那么get()函数将会阻塞，直到该值可用。
• std::promise也是一个类模板，其调用对象有可能在将来对值进行赋值，每个std::promise对象有一个在内部对应的std::future对象，可以由get_future方法获得，并且通过set_value为future对象赋值。
• std::promise对象与其管理的std::future对象共享数据。

逐步解析

在线程1中创建一个std::promise对象

std::promise<int> promiseObj;

目前为止，该promise对象没有任何管理的值，但它承诺肯定会有人对其进行赋值，一旦被赋值，就可以通过其管理的std::future对象的get()方法来获取该值。

但是，假设线程1创建了该promise对象并将其传给线程2，那么线程1怎样知道线程2什么时候会对promise对象进行赋值呢？

答案是使用std::future对象

每个std::promise对象都有个对应的std::future对象，其他人可以通过它来获取promise设置的值。所以，线程1将会创建std::promise对象，然后在将其传递给线程2之前从它那里获取std::future对象。

std::future<int> futureObj = promiseObj.get_future();

现在，线程1将promiseObj传递给线程2.

那么线程1将会获取到线程2通过std::future的get函数设置在std::promise中的值，

int val = futureObj.get();

但是如果线程2还没有对该值进行设置，那么这个调用将会阻塞，直到线程2在promise对象中对该值进行设置。

promiseObj.set_value(45);

看一个完整的std::future和std::promise的例子：

#include <iostream>
#include <thread>
#include <future>
 
void initiazer(std::promise<int>* promObj){
	std::cout<<"Inside Thread"<<std::endl;
	promObj->set_value(35);
}
 
int main(){
	std::promise<int> promiseObj;
	std::future<int> futureObj = promiseObj.get_future();
	std::thread th(initiazer, &promiseObj);
	std::cout<<futureObj.get()<<std::endl;
	th.join();
 
	return 0;
}

如果std::promise对象在赋值之前被销毁，那么管理的std::future对象上的get()调用将会抛出异常。

除此之外，如果想要线程在不同时间点返回多个值，只需要在线程中传输多个std::promise对象，并从相关的多个std::futur对象中获取多个返回值。

下一节，介绍下怎样将std::future和std::async、std::packaged_task一起使用.

async

本节讨论下在C++11中怎样使用std::async来执行异步task。

C++11中引入了std::async

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

template<class Fn, class... Args>
future<typename result_of<Fn(Args...)>::type> async(launch policy, Fn&& fn, Args&&...args);

std::async返回一个 std::future，它存储由 std::async()执行的函数对象返回的值。

函数期望的参数可以作为函数指针参数后面的参数传递给std::async()。

std::async中的第一个参数是启动策略，它控制std::async的异步行为，我们可以用三种不同的启动策略来创建std::async

• std::launch::async 保证异步行为，即传递函数将在单独的线程中执行
• std::launch::deferred 当其他线程调用get()来访问共享状态时，将调用非异步行为，也就是同步行为
• std::launch::async | std::launch::deferred 默认行为。有了这个启动策略，它可以异步运行或不运行，这取决于系统的负载，但我们无法控制它。

如果我们不指定一个启动策略，其行为将类似于std::launch::async | std::launch::deferred

本节我们将使用std::launch::async启动策略

我们可以在std::async传递任何回调，如：

• 函数指针
• 函数对象
• lambda表达式

std::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::string fileData = fetchDataFromFile("Data");
 
  //从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，用lambda函数作为回调调用std::async

#include <iostream>
#include <string>
#include <chrono>
#include <thread>
#include <future>
 
using namespace std::chrono;
 
//Function Object
struct DataFetcher {
  std::string operator ()(std::string recvdData) {
    //确保函数要5秒才能执行完成
    std::this_thread::sleep_for(seconds(5));
    //处理获取文件数据
    return "File_" + recvdData;
    }
  };
 
int main() {
  //获取开始时间
  system_clock::time_point start = system_clock::now();
 
  //lambda
  std::future<std::string> resultFromDB = std::async([](std::string recvdData) {
    std::this_thread::sleep_for(seconds(5));
    //处理创建数据库连接、获取数据等事情
    return "DB_" + recvdData; 
    }, "Data"); 
 
  //用函数对象调用std::async
  std::future<std::string> fileResult = std::async(DataFetcher(), "Data");
  std::string fileData = fileResult.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;
}