C++11的future和promise及active object并发模式
一、模式介绍：
《C++并发编程实战》中提到了C++11中的future，网上查找一些资料大都只说了使用，并没有详细介绍future。
在《面向模式的软件架构卷二》第五章中介绍了并发模式，其中future属于active object模式。该模式将方法执行和方法调用分离，改善并发行、简化对位于独立控制线程中的对象的同步访问。
该模式主要解决以下问题：
1. 调用一个并发对象的处理密集型方法时，不应该阻塞整个进程，一面影响其他并发对象的服务质量。
2. 同步访问共享对象的代码应该容易编写，即客户端调用共享对象受同步约束限制的方法时，方法调用的串行化和调度应该是透明的。
注：原书第三点为：应用程序应该能够透明的利用硬件／软件平台的并行性，可是c++的future并非完全使用多线程，也有在本线程中基于回调的实现。
二、模式结构：
active object模式由六个部分组成。
1. Proxy：代理提供接口使客户端能够调用主动对象，当代理被调用时，将创建一个future对象，一个方法请求，并将方法请求添加到激活队列中。
2. Future：future存储主动对象方法的结果，也向客户端提供汇合点。
3. Method Request：具体方法请求将包含具体实现。
4. Scheduler：调度器通过激活列表来管理及调度方法请求，运行在异步线程中（c++是否也可能在本线程？）。
5. ActivationQueue：激活列表维护待执行的方法请求，由代理添加，在调度器中移除。
6. Servant：Servant实现主动对象，完成后通过future与客户端汇合。
图来自http://www.ibm.com/developerworks/cn/java/j-lo-activeobject/
模式的具体行为分三个阶段：
1. 客户端通过代理，创建方法请求，并返回一个future，同时代理将方法请求添加到激活列表。
2. 调度器监控激活列表，选择可运行的方法请求，从激活列表中删除，并绑定到Servant中，并在Servant中调用方法请求的具体实现。
3. Servant完成后将结果存储到future中，调度器继续监视激活列表。客户端可以通过future获取结果。
三、c++11的future：
future对象是一个记录异步事件值及执行状态的对象，异步事件有两种状态：
1. 异步事件尚未执行完成，该future未就位。
2. 异步事件正常结束或者抛出异常，该future已就位（future_status::ready），包括成功就位和异常。
future对象只能被赋值一次，一旦被赋值或者触发异常以后，future对象就无法改变。
future对象由async和packaged_task和promise（特殊的future）产生。普通future结果由异步事件返回值记录。
promise是一类特殊的future，promise可以显式传递值（甚至是异常），功能看起来更像是Go语言中的不带缓冲区的阻塞型Channel。（是否也是CSP？）
future可以同时创建多个任务，在主线程上注册异步事件（可以通过async，或者packaged_task，不过packaged_task需要有一个载体或者说是运行环境，如thread）通过launch::async和launch::deferred控制异步执行的时机，async会选择是否创建一个新的线程进行处理异步函数，如果没有async疑似会使用类似回调的机制执行异步调用。deferred控制异步执行的时机，带有deferred的async的future，会在future.get的时候才进行异步执行[2]。但是future的结果查询是由注册者主动进行查询，而不是回调（与reactor不同的是reactor基于IO多路复用机制避免了一个轮询，从而封装成一个回调的机制。而对异步事件封装的话最下层对异步结果的轮询不可避免，或者对所有的future进行时间管理，通过时间堆的最小值来进行future.sleep_for ()？）
future实现了对任务的并发管理，但是并不一定是真正的并行执行。
四、async简单用例：
<span style="font-size:14px;">#include <iostream>
#include <thread>
#include <future>
#include <unistd.h>
using namespace std;
int foo ()
{
cout << this_thread::get_id () << "Foo" << endl;
return 100;
}
int main ()
{
#ifdef ASYNC
future<int> ans = async (launch::async, foo);
#endif
#ifdef DEFER
future<int> ans = async (launch::deferred, foo);
#endif
#ifdef ALL
future<int> ans = async (launch::async | launch::deferred, foo);
#endif
#ifdef DEFAULT
future<int> ans = async (foo);
#endif
cout << this_thread::get_id () << "Main" << endl;
sleep (2);
cout << "Get answer " << endl;
cout << ans.get () << endl;
}</span>
执行结果：$ h++ async.cpp -lpthread -O2 -DDEFAULT
$ ./a.out
140008293058336Main
Get answer
140008293058336Foo
100
$ h++ async.cpp -lpthread -O2 -DDEFER
$ ./a.out
140209737066272Main
Get answer
140209737066272Foo
100
$ h++ async.cpp -lpthread -O2 -DASYNC
$ ./a.out
140555780749088Main
140555780740864Foo
Get answer
100
$ h++ async.cpp -lpthread -O2 -DALL
$ ./a.out
140517193733920Main
Get answer
140517193733920Foo
100
promise简单例子：
<span style="font-size:14px;">#include <iostream>
#include <functional>
#include <thread>
#include <future>
#include <chrono>
using namespace std;
int foo (future<int> &fut)
{
cout << this_thread::get_id () << "Foo" << endl;
int res = fut.get () * 100;
cout << res << " In foo" << endl;
return res;
}
int main ()
{
promise<int> p;
future<int> pf = p.get_future ();
future<int> f = async (launch::async, foo, ref (pf));
cout << this_thread::get_id () << "Main" << endl;
this_thread::sleep_for (chrono::seconds (2));
cout << "Awake" << endl;
p.set_value (100);
cout << f.get () << " In main." << endl;
return 0;
}</span>
执行结果：异步事件被阻塞，直到主函数
139658737252128Main
139658737243904Foo
Awake
10000 In foo
10000 In main.
参考文献：
[1] http://blog.csdn.net/lmdcszh/article/details/39696357
[2] http://www.cplusplus.com/reference/future/launch/
[3] 一二章参考《面向模式的软件架构卷二》第五章第一节，Active Object模式