C# · 12月 20, 2021

新手学C/C++:一篇代码学会使用std::future , std::promise std::async std::packaged_task完成多线程编程的回调实现

#include

#include

#include

#include

#include

using namespace std::chrono;

struct testDb

{

    std::string operator()(std::string recvData){

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

        return “Db_” + recvData;

    }

};

struct testFile

{

    std::string operator()(std::string recvData){

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

        return “File_” + recvData;

    }

};

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;

}

void fetchDataFromDB1(std::promise* promiSEObj,std::string recvData) {

    //确保函数要5秒才能执行完成

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

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

    promiSEObj->set_value(“DB_” + recvData);

}

void fetchDataFromFile1(std::promise* promiSEObj,std::string recvData) {

    //确保函数要5秒才能执行完成

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

    

    //处理获取文件数据

    promiSEObj->set_value(“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(end – start).count();

    //std::cout << "Total Time taken= " << diff << "Seconds" << std::endl;

    ////组装数据

    //std::string data = dbData + ” :: ” + fileData;

    ////输出组装的数据

    //std::cout << "Data = " << data.c_str() << std::endl;

    std::cout << "————————————————————————–" << std::endl;

    //c++11的方法:使用std::future 和 std::promise

    //system_clock::time_point start1 = system_clock::Now();

    //std::promise promiSEObj;

    //std::future futureDB = promiSEObj.get_future();

    //std::thread th(fetchDataFromDB1,&promiSEObj,”Data”);

    //std::promise promiseFile;

    //std::future futureFile = promiseFile.get_future();

    //std::thread th1(fetchDataFromFile1,&promiseFile,”Data”);

    //th.join();

    //th1.join();

    //std::string dbData1 = futureDB.get();

    //std::string fileData1 = futureFile.get();

    //auto end1 = system_clock::Now();

    //auto diff1 = duration_cast(end1 – start1).count();

    //std::cout << "Total Time taken= " << diff1 << "Seconds" << std::endl;

    //std::string data1 = dbData1 + ” :: ” + fileData1;

    //std::cout << "Data1 = " << data1.c_str() << std::endl;

    std::cout << "————————————————————————–" << std::endl;

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

    /*auto start2 = system_clock::Now();

    std::future futureDB2 = std::async([](std::string recvData){std::this_thread::sleep_for(seconds(5)); return “DB_” + recvData; },”Data”);

    std::future futureFile2 = std::async([](std::string recvData){    std::this_thread::sleep_for(seconds(5)); return “File_” + recvData; },”Data”);

    std::string dbData2 = futureDB2.get();

    std::string fileData2 = futureFile2.get();

    auto end2 = system_clock::Now();

    auto diff2 = duration_cast(end2 – start2).count();

    std::cout << "Total Time taken= " << diff2 << "Seconds" << std::endl;

    std::string data2 = dbData2 + ” :: ” + fileData2;

    std::cout << "Data2 = " << data2.c_str() << std::endl;*/

    std::cout << "————————————————————————–" << std::endl;

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

    /*auto start3 = system_clock::Now();

    std::future futureDB3 = std::async(testDb(),”Data”);

    std::future futureFile3 = std::async(testFile(),”Data”);

    std::string dbData3 = futureDB3.get();

    std::string fileData3 = futureFile3.get();

    auto end3 = system_clock::Now();

    auto diff3 = duration_cast(end3 – start3).count();

    std::cout << "Total Time taken= " << diff3 << "Seconds" << std::endl;

    std::string data3 = dbData3 + ” :: ” + fileData3;

    std::cout << "Data3 = " << data3.c_str() << std::endl;*/

    std::cout << "————————————————————————–" << std::endl;

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

    //auto start4 = system_clock::Now();

    //std::future futureDB4 = std::async(std::launch::async | std::launch::deferred,fetchDataFromDB,”Data”);

    //std::future futureFile4 = std::async(std::launch::async | std::launch::deferred,fetchDataFromFile,”Data”);

    //std::string dbData4 = futureDB4.get();

    //std::string fileData4 = futureFile4.get();

    //auto end4 = system_clock::Now();

    //auto diff4 = duration_cast(end4 – start4).count();

    //std::cout << "Total Time taken= " << diff4 << "Seconds" << std::endl;

    //std::string data4 = dbData4 + ” :: ” + fileData4;

    //std::cout << "Data4 = " << data4.c_str() << std::endl;

    std::cout << "————————————————————————–" << std::endl;

    ////使用函数指针创建packaged_task来完成回调需求

    //auto start5 = system_clock::Now();

    //std::packaged_task taskDB(fetchDataFromDB);

    //std::packaged_task taskFile(fetchDataFromFile);

    //std::future futureDB5 = taskDB.get_future();

    //std::future futureFile5 = taskFile.get_future();

    //std::thread th5DB(std::move(taskDB),”Data”);

    //std::thread th5File(std::move(taskFile),”Data”);

    //th5DB.join();

    //th5File.join();

    //std::string dbData5 = futureDB5.get();

    //std::string fileData5 = futureFile5.get();

    //auto end5 = system_clock::Now();

    //auto diff5 = duration_cast(end5 – start5).count();

    //std::cout << "Total Time taken= " << diff5 << "Seconds" << std::endl;

    //std::string data5 = dbData5 + ” :: ” + fileData5;

    //std::cout << "Data5 = " << data5.c_str() << std::endl;

    std::cout << "————————————————————————–" << std::endl;

    

    ////使用函数对象创建packaged_task来完成回调需求

    /*auto start6 = system_clock::Now();

    std::packaged_task taskDB(std::move(testDb()));

    std::packaged_task taskFile(std::move(testFile()));

    std::future futureDB6 = taskDB.get_future();

    std::future futureFile6 = taskFile.get_future();

    std::thread th6DB(std::move(taskDB),”Data”);

    std::thread th6File(std::move(taskFile),”Data”);

    th6DB.join();

    th6File.join();

    std::string dbData6 = futureDB6.get();

    std::string fileData6 = futureFile6.get();

    auto end6 = system_clock::Now();

    auto diff6 = duration_cast(end6 – start6).count();

    std::cout << "Total Time taken= " << diff6 << "Seconds" << std::endl;

    std::string data6 = dbData6 + ” :: ” + fileData6;

    std::cout << "Data6 = " << data6.c_str() << std::endl;*/

    std::cout << "————————————————————————–" << std::endl;

    

    /*auto start7 = system_clock::Now();

    std::packaged_task taskDB([](std::string recvData){std::this_thread::sleep_for(seconds(5)); return “DB_” + recvData; });

    std::packaged_task taskFile([](std::string recvData) {std::this_thread::sleep_for(seconds(5)); return “File_” + recvData;});

    std::future futureDB7 = taskDB.get_future();

    std::future futureFile7 = taskFile.get_future();

    std::thread th7DB(std::move(taskDB),”Data”);

    std::thread th7File(std::move(taskFile),”Data”);

    th7DB.join();

    th7File.join();

    std::string dbData7 = futureDB7.get();

    std::string fileData7 = futureFile7.get();

    auto end7 = system_clock::Now();

    auto diff7 = duration_cast(end7 – start7).count();

    std::cout << "Total Time taken= " << diff7 << "Seconds" << std::endl;

    std::string data7 = dbData7 + ” :: ” + fileData7;

    std::cout << "Data7 = " << data7.c_str() << std::endl;*/

    system(“pause”);

    return 0;

}