多线程的创建：std::async和std::thread的不同之处

一.std::thread 和 std::async

1.thread
我们在调用thread函数语句时，直接会在主线程中创建一个线程。
但是如果系统资源紧张，线程创建就会失败，执行thread()函数时整个程序可能会崩溃

2.async与deferred

而std::async是创建一个异步任务，因为有时候async并不创建新线程，需要在调用该任务时，入口函数才会执行。

async和deferred的不同之处是async强制任务创建新线程执行函数，而deferred不是，所以deferred是在调用处中延迟执行任务。与判断联合使用，可以防止线程过多导致系统崩溃。

//async（）默认参数为std::launch::async,
//任务已经创建，线程也强制创建，执行函数
std::future<int> result=std::async(gatewayFunction，para);
//进行各种运算。。。。。
cout<<result.get()<<endl;//得到任务计算后的返回值


using namespace std:
//任务已经创建，线程不创建，不执行函数
std::future<int> result=std::async(launch::deferred,gatewayFunction，para);
//进行各种运算。。。。。
cout<<result.get()<<endl;//任务才被执行，调用入口函数，不创建新线程，得到任务计算后的返回值

用std::async代替线程的创建

　　std::async是来帮忙的，帮忙封装，让以上三个对象默契地工作。大致的工作过程如下：std::async先将异步操作用std::packaged_task包装起来，然后将异步操作的结果放到std::promise中，这个过程就是创造未来的过程；外面再通过future.get/wait来获取这个未来的结果。不用再想到底该怎么用std::future、std::promise和std::packaged_task了，std::async已经帮你搞定一切了！
 

　　现在来看看std::async的原型async(std::launch::async | std::launch::deferred, f, args...)。

• 第一个参数是线程的创建策略，有两种策略，默认的策略是立即创建线程：
  • std::launch::async：在调用async就开始创建线程。
  • std::launch::deferred：延迟加载方式创建线程。调用async时不创建线程，直到调用了future的get或者wait时才创建线程。
• 第二个参数是线程函数
• 第三个参数是线程函数的参数

std::async基本用法：

#include <future>
#include <iostream>
 
 
int 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 << 8 << std::endl; }); 
    f2.wait(); //output: 8
     
    std::future<int> future = std::async(std::launch::async, [](){ 
            std::this_thread::sleep_for(std::chrono::seconds(3));
            return 8;  
        }); 
     
    std::cout << "waiting...\n";
    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); 
    
    std::cout << "result is " << future.get() << std::endl;
}

3.async|deferred
async与deferred都是16进制枚举类型的符号，所以可以进行运算。 当进行或运算的时候，意味着系统将依据情况选择延迟或者立刻创建线程。
当async()中没有launch参数的时候，系统默认补充async|deferrred参数。系统会自行确定创建新线程还是延迟。

系统决定是异步async（创建新线程）还是同步deferred（不创建新线程）方式运行，取决于当时的内存环境，系统状态。所以async()比thread()硬创建线程，造成系统崩溃，更容易维护程序运行的稳定性。

enum class launch { // names for launch options passed to async
    async    = 0x1,
    deferred = 0x2
};

std::future<int>result=std::async (launch::async|launch::deferred,gateF,para)

二：不同之处

1.async()不一定创建新线程，系统自行判断，thread()一定创建。
2.async()可以通过future 获取到返回值。

如何自行判断？与 future的wait_for函数联合使用。

 

std::future

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

• deferred：异步操作还没开始
• ready：异步操作已经完成
• timeout：异步操作超时

获取future结果有三种方式：

• get：等待异步操作结束并返回结果
• wait：等待异步操作完成，没有返回值
• wait_for是超时等待返回结果。

cout<<"This thread id is "<<_threadid<<endl;
std::future<int> result=std::async(launch::async|launch::deferred,mythread);


//查询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); 

std::promise

　　std::promise为获取线程函数中的某个值提供便利：在线程函数中给外面传进来的promise赋值，当线程函数执行完成之后就可以通过promise获取该值了。值得注意的是取值是间接地通过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();

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();

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。