async和Future

=================================版权声明=================================

版权声明：原创文章 禁止转载 

请通过右侧公告中的“联系邮箱（wlsandwho@foxmail.com）”联系我

勿用于学术性引用。

勿用于商业出版、商业印刷、商业引用以及其他商业用途。　　　　　　　　　　　　　　　　   

 

本文不定期修正完善。

本文链接：https://www.cnblogs.com/wlsandwho/p/13837290.html

耻辱墙：http://www.cnblogs.com/wlsandwho/p/4206472.html

=======================================================================

C++ 异步

=======================================================================

如果可能，创建一个线程执行DoSomething(1),

根据被执行函数的实际耗时，res=f.get()+res2会有不同行为，

但最终都会执行。

注意：

1 async支持显式的发射策略，虽然指明async策略可以不用再调用get，但是为了统一和更明确，调一下也无妨，万一根据代码量评估绩效呢。

2 一个future对象的get方法只能被调用一次，之后的调用是无效的。（用valid方法检测）

但是wait方法可以调用多次。（但是不返回结果，需要再调用get。）

3 wait_for和wait_until不会让defferred的任务启动

4 wait和get一定会让任务启动并完成。

// AsyncAndFuture.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <windows.h>

#include <iostream>
#include <future>

//////////////////////////////////////////////////////////////////////////
int DoSomething(int n)
{
    //模拟功能的函数
    Sleep(n * 1000);

    return n;
}

int DoSomethingWithMagic(int n)
{
    //模拟功能的函数
    Sleep(n * 999);

    return n;
}

int DoSomethingWithShow(int n)
{
    //模拟功能的函数
    std::cout << "Do\n";
    Sleep(n * 1000);
    std::cout << "Done\n";

    return n;
}

int DoSomethingByVal(int i,const std::shared_future<int>& sf)
{
    int val = sf.get();

    return i + val;
}

//////////////////////////////////////////////////////////////////////////
void Test1()
{
    //基本用法

    std::future<int> f = std::async(DoSomething, 1);

    int res2 = DoSomething(2);

    int res = f.get() + res2;

    std::cout << res << std::endl;
}

//////////////////////////////////////////////////////////////////////////
void Test2()
{
    //发射策略

    //std::future<int> f = std::async(std::launch::async,DoSomething,1);
    //std::future<int> f = std::async(std::launch::deferred,DoSomething,1);
}

//////////////////////////////////////////////////////////////////////////
void Test3()
{
    //缓式求值

    auto f1 = std::async(std::launch::deferred, DoSomething, 1);
    auto f2 = std::async(std::launch::deferred, DoSomething, 2);

    bool bWhich = true;
    auto res = bWhich ? f1.get() : f2.get();
    std::cout << res << std::endl;
}

//////////////////////////////////////////////////////////////////////////
void Test4()
{
    //wait可调用多次，get只能调用一次

    auto f1 = std::async(std::launch::deferred, DoSomething, 1);
    f1.wait();
    //f1.wait();//多次调用，没问题
    auto res=f1.get();

    std::cout << res << std::endl;

    //auto res2 = f1.get();//多次调用，此处异常
}

//////////////////////////////////////////////////////////////////////////
void Test5()
{
    //虽然同一个future对象的get只能调用一次，
    //但是给future对象赋值后，又有了新的对象，又是一条好汉，可以调用（看汇编是用的forward实现的=重载）

    int res = 0;

    std::future<int> f = std::async(DoSomething, 1);
    res = f.get();
    std::cout << res << std::endl;

    f = std::async(DoSomething, 2);
    res = f.get();
    std::cout << res << std::endl;
}

//////////////////////////////////////////////////////////////////////////
class CBestRest
{
public:
    std::future<int> f;
};

CBestRest oBR;

void Test6()
{
    //投机性运行,选取有限时间内最好的结果

    int res = 0;

    //尝试用一种方法得到精确解
    auto deadline = std::chrono::system_clock::now() + std::chrono::seconds(3);
    oBR.f = std::async(DoSomethingWithMagic, 5);

    //规规矩矩的解，不是很精确
    int resguess = DoSomething(2);

    //时间到了，算出精确解就用，万一精确解没算完，我们就用普通的解
    std::future_status fs = oBR.f.wait_until(deadline);
    if (fs==std::future_status::ready)
    {
        res = oBR.f.get();
    }
    else
    {
        res = resguess;
    }

    std::cout << res << std::endl;
}

//////////////////////////////////////////////////////////////////////////
void Test7()
{
    //使用shared_future，多次调用get

    std::shared_future<int> sf = std::async(std::launch::async, DoSomething, 5);

    auto f1 = std::async(DoSomethingByVal, 1, sf);
    auto f2 = std::async(DoSomethingByVal, 2, sf);
    auto f3 = std::async(DoSomethingByVal, 3, sf);

    //这三行是顺序的，这里是在等结果，因为它们的耗时以最大的那个为准，所以还是可以看作并行的。
    int res1 = f1.get();
    int res2 = f2.get();
    int res3 = f3.get();

    std::cout    << res1 << std::endl
                << res2 << std::endl
                << res3 << std::endl;
}

//////////////////////////////////////////////////////////////////////////
void Test8()
{
    //wait_for不会启动任务(wait_until同理)
    std::future<int> f = std::async(std::launch::deferred,DoSomethingWithShow, 2);
    std::future_status fs = f.wait_for(std::chrono::seconds(1));

    if (fs==std::future_status::deferred)
    {
        std::cout << "Did not Run for deferred\n";
    }

    getchar();

    //任务超时的例子
    std::future<int> f2 = std::async(std::launch::async, DoSomethingWithShow, 2);
    std::future_status fs2 = f2.wait_for(std::chrono::seconds(1));

    if (fs2 == std::future_status::timeout)
    {
        std::cout << "Run but timeout\n";
    }
}


int main()
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
    Test8();

    getchar();

    return 0;
}

 

运行结果（Test8输入了一个a并回车以便让程序继续运行）