C++多线程的简单使用

多线程的使用，本文主要简单介绍使用多线程的几种方式，并使用几个简单的例子来介绍多线程，使用编译器为visual studio。

一、AsyncFuture

使用的知识点有std::async和std::future

1、std::async函数原型

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

功能：第二个参数接收一个可调用对象（仿函数、lambda表达式、类成员函数、普通函数......）作为参数,并且异步或是同步执行他们。

对于是异步执行还是同步执行，由第一个参数的执行策略决定：

（1）std::launch::async 传递的可调用对象异步执行；

（2）std::launch::deferred 传递的可调用对象同步执行；

（3）std::launch::async | std::launch::deferred 可以异步或是同步，取决于操作系统，我们无法控制；

（4）如果不指定具体的策略，则默认执行（3）。

如果选择异步执行策略，调用get时，如果异步执行没有结束，get会阻塞当前调用线程，直到异步执行结束并获得结果，如果异步执行已经结束，不等待获取执行结果；如果选择同步执行策略，只有当调用get函数时，同步调用才真正执行，这也被称为函数调用被延迟。

返回结果std::future的状态：

（1）deffered：异步操作还没有开始；

（2）ready：异步操作已经完成；

（3）timeout：异步操作超时。

例子

#include "stdfax.h"

/*
    std::async,std::future   
*/
int main()
{
    // step1  possibly start thread immediately
    std::future ft1(std::async(sum, 1, 11));
    std::future ft2(std::async(sum, 1, 101));

    try {
        // step2  to get result we have to call future.get()
        int a = ft1.get();
        int b = ft2.get();

        cout << a << " + " << b << " = " << a + b << endl;
    }
    catch (std::exception& e)
    {
        cout << e.what() << endl;
    }
    
    return 0;
}

二、PackageTaks

使用的知识点有std::package_task和std::future

1、std::package_task是一个模板类

std::packaged_task包装任何可调用目标(函数、lambda表达式、bind表达式、函数对象)以便它可以被异步调用。它的返回值或抛出的异常被存储于能通过std::future对象访问的共享状态中。

例子

#include "stdfax.h"

/*
	std::package_task, std::promise,std::future
*/

int main()
{
   // step 1 does not start thread yet
	std::packaged_task task1(sum);
	std::packaged_task task2(sum);

	// step2  create future using task
	std::future ft1 = task1.get_future();
	std::future ft2 = task2.get_future();

	// step3 we have to start the thread
	// start the task (or thread)
	task1(1, 11);
	task2(1, 101);

	try {
		// step 4  now get the result of processing
		int a = ft1.get();
		int b = ft2.get();

		cout << a << " + " << b << " = " << a + b << endl;
	}
	catch (std::exception& e)
	{
		cout << e.what() << endl;
	}
}

三、PromiseFuture

使用的知识点有std::thread，std::promise和std::future

1、std::future

std::future期待一个返回，从一个异步调用的角度来说，future更像是执行函数的返回值，C++标准库使用std::future为一次性事件建模，如果一个事件需要等待特定的一次性事件，那么这线程可以获取一个future对象来代表这个事件。异步调用往往不知道何时返回，但是如果异步调用的过程需要同步，或者说后一个异步调用需要使用前一个异步调用的结果。这个时候就要用到future。

2、std::promise

promise 对象可以保存某一类型 T 的值，该值可被 future 对象读取（可能在另外一个线程中），因此 promise 也提供了一种线程同步的手段。在 promise 对象构造时可以和一个共享状态（通常是std::future）相关联，并可以在相关联的共享状态(std::future)上保存一个类型为 T 的值。

可以通过 get_future 来获取与该 promise 对象相关联的 future 对象，调用该函数之后，两个对象共享相同的共享状态(shared state)

• promise 对象是异步 Provider，它可以在某一时刻设置共享状态的值。
• future 对象可以异步返回共享状态的值，或者在必要的情况下阻塞调用者并等待共享状态标志变为 ready，然后才能获取共享状态的值。

get_future()

此函数返回一个与 promise 共享状态相关联的 future 。返回的 future 对象可以访问由 promise 对象设置在共享状态上的值或者某个异常对象。只能从 promise 共享状态获取一个 future 对象。在调用该函数之后，promise 对象通常会在某个时间点准备好(设置一个值或者一个异常对象)，如果不设置值或者异常，promise 对象在析构时会自动地设置一个 future_error 异常(broken_promise)来设置其自身的准备状态。

例子

#include "stdfax.h"

/*
	std:thread,std::promise,std:future
*/
int main()
{
	// step 1 create a promise with return type
	std::promise prm,prm2;

	// step 2 create a future using the promise
	std::future ft = prm.get_future();
	std::future ft2 = prm2.get_future();

	// step 3 create a thread using promise
	std::thread thr(sum_prm, std::ref(prm), 1, 11);
	std::thread thr2(sum_prm, std::ref(prm2), 1, 101);

	// step 4 detach thread
	// you should not forget this step
	thr.detach();
	thr2.detach();

	try {
		// step 5 now get the result of processing
		int a = ft.get();
		int b = ft2.get();

		cout << a << " + " << b << " = " << a + b << endl;
	}
	catch (std::exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

零、例子的通用代码

stdafx.h

#include 
#include 

#include "thread_inc.h"

stdafx.cpp

#include "stdfax.h"

#include "thread_inc.cpp"

thread_inc.h

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;   

extern int sum(int st, int ed);
extern void sum_prm(std::promise& prm, int st, int ed);

thread_inc.cpp 此文件的代码不参与生成，点击thread_inc.cpp，右键属性，在常规-》项目类型，设置不参与生成。

int sum(int st, int ed)
{
	int rlt = 0;

	for (int i = st; i < ed; ++i)
	{
		// 设置异常
		if (i == (st + ed) / 2)
		{
			std::ostringstream os;
			os << "sum(" <& prm, int st, int ed)
{
	int rlt = 0;

	try {
		for (int i = st; i < ed; ++i)
		{
			// 设置异常
			if (i == (st + ed) / 2)
			{
				std::ostringstream os;
				os << "sum_prm(" << st << ", " << ed << ") - throw exception at: " << i;

				throw std::runtime_error(os.str().c_str());
			}

			rlt += i;
		}

		// prm.set_value(rlt);
		prm.set_value_at_thread_exit(rlt);
	}
	catch (std::exception& e)
	{
		//prm.set_exception(std::current_exception() )
		prm.set_exception_at_thread_exit(std::current_exception());
	}
}