// future::operator=

 #include <iostream>       // std::cout

 #include <future>         // std::async, std::future

 int get_value() { return ; }

 int main ()

 {

   std::future<int> fut;           // default-constructed, 默认构造的 future 对象是无效的

 // async()返回的就是一个 uture 对象。 fut = future_returned_by_async(), 调用 future 的赋值运算符。

 // move-assigned，赋值运算符隐式使用的是 move 语意(非c++98的拷贝语意)， fut = 这使得 fut 变的有效。同时使得右操作数变的无效

  fut = std::async (get_value);

  //async创建并运行一个线程，返回一个与函数返回值相对应类型的 future，通过它我们可以在其他任何地方获取异步结果

  //Calling future::get on a valid future blocks the thread until the provider makes the shared state ready return 0;

  std::cout << "value: " << fut.get() << '\n';

 }

 packaged_task<int(int)> myPackaged(task);

 //首先创建packaged_task对象myPackaged，其内部创建一个函数task和一个共享状态(用于返回task的结果)

 future<int> myFuture = myPackaged.get_future();

 //通过 packaged_task::get_future() 返回一个future对象myFuture用于获取task的任务结果

 thread myThread(move(myPackaged),"hello world");

 //创建一个线程执行task任务，这里注意move语义强制将左值转为右值使用因为packaged_task禁止copy constructor，可以不创建线程，那么task任务的执行将和future结果的获取在同一个线程，这样就不叫异步了

 //这里主线程可以做其它的操作

 int x = myFuture.get();

 //线程还可以在执行一些其它操作，直到其想获取task的结果时调用此语句 

 #include <iostream>       // std::cout

 #include <functional>     // std::ref

 #include <thread>         // std::thread

 #include <future>         // std::promise, std::future  

 void print_int (std::future<int>& fut) {

   int x = fut.get();//当promise::set_value()设置了promise的共享状态值后，

   // fut将会通过future::get()获得该共享状态值，若promise没有设置该值那么

   // fut.get()将会阻塞线程直到共享状态值被promise设置

   std::cout << "value: " << x << '\n';//输出：<span style="font-family: monospace; white-space: pre; rgb(231, 231, 231);">value: 10</span>

 }  

 int main ()

 {

   std::promise<int> prom; //创建一个promise对象

   std::future<int> fut = prom.get_future(); //获取promise内部的future，fut将和promise共享promise中的共享状态，

   // 该共享状态用于返回计算结果

   std::thread th1 (print_int, std::ref(fut));  //创建一个线程，并通过引用方式将fut传到print_int中

   prom.set_value ();    //设置共享状态值

                                                //

   th1.join();//等待子线程

   return ;

 } 

 future() noexcept;//创建一个空的future，其不和任何共享状态相关，注意该future是invalid的，但是其可以move

 future (const future&) = delete;//禁止拷贝构造

 future (future&& x) noexcept;//具有move语义

 ~future();//解除和某个共享状态的关联，若该future是最后一个和共享状态关联的则共享状态也被销毁，

 // 因为future是禁止拷贝的，所以这里最后一个可以理解为该future是valid的(和某个共享状态关联)

 future& operator= (future&& rhs) noexcept;//移动赋值，若rhs是valid的那么赋值后rhs将不再和该共享状态关联，

 // 赋值后的future和该共享状态关联

 future& operator= (const future&) = delete;//禁止拷贝赋值

 shared_future<T> share();//返回一个shared_future，shared_future允许多个shared_future和共

 // 享状态关联并且可以多次get，而future只允许一个future和共享状态关联。调用share()的future不再

 // 和共享状态关联，如future<int> f=async(task); shared_future<int> sh=f.share(); f.get(); f.get()*2;

 bool valid() const noexcept;//若future和共享状态关联则返回true，否则返回false

 T get();//若future和某个T类型的共享状态关联，那么调用future::get()，

 // 若该状态还没有准备好阻塞线程直到准备好，若状态准备好了，则返回该状态值，

 // 并将future和共享状态解绑，此future将invalid

 void wait() const;//阻塞等待共享状态就绪

 future_status wait_for (const chrono::duration<Rep,Period>& rel_time) const;

 //在rel_time时间内等待共享状态值就绪

 future_status wait_until (const chrono::time_point<Clock,Duration>& abs_time) const;

 //直到abs_time时刻等待共享状态就绪  

 async (Fn&& fn, Args&&... args);

 //自动选择线程执行任务fn，args是fn的参数，若fn是某个对象的非静态成员函数那么第

 // 一个args必须是对象的名字，后面的args是fn所需的参数

 async (launch policy, Fn&& fn, Args&&... args);//有三种方式policy执行任务fn

 policy=launch::async表示开启一个新的线程执行fn

 policy=launch::deferred 表示fn推迟到future::wait/get时才执行

 policy=launch::async|launch::deferred表示由库自动选择哪种机制执行fn，和第一种构造方式async(fn,args)策略相同  

 packaged_task() noexcept;//空的packaged_task对象，没有共享状态和内部函数

 explicit packaged_task (Fn&& fn);//内部有共享状态和函数fn

 explicit packaged_task (allocator_arg_t aa, const Alloc& alloc, Fn&& fn);

 //共享状态通过alloc分配内存(该共享状态可能是个buffer)

 packaged_task (const packaged_task&) = delete;//禁止拷贝构造

 packaged_task (packaged_task&& x) noexcept;//具有移动语义  

 ~packaged_task();//丢弃共享状态，若还有future和共享状态关联，

 // 那么共享状态不会被销毁直到future销毁，如果析构发生时共享

 // 状态还没有被设置那么析构将设置共享状态并在状态里加入异常  

 packaged_task& operator= (packaged_task&& rhs) noexcept;//rhs的共享状态将被移动，rhs将没有共享状态

 ackaged_task& operator= (const packaged_task&) = delete;//禁止拷贝  

 bool valid() const noexcept;//若packaged_task内部有共享状态则返回true，否则返回false

 future<Ret> get_future();//返回一个future用以获得共享状态，该函数只能被调用一次  

 void operator()(Args... args);//执行fn，若成功则将结果写入共享状态，

 // 若失败则写入异常到共享状态，通过future::get()可以获取该状态

 void make_ready_at_thread_exit (args... args);//结果介入共享状态，

 // 但是在该函数所在的调用线程结束后才使共享状态就绪，即该线程结束

 // 后future::get()才能获取状态值，若在写入状态值和线程没有退出期间有写入该状态的行为将抛出future_error的异常  

 void swap (packaged_task& x) noexcept;//交换两个packaged_task的内部share state 和 callable object  

 promise();//空的promise对象，没有共享状态值

 template <class Alloc> promise (allocator_arg_t aa, const Alloc& alloc);//Alloc将为共享状态值开辟内存

 promise (const promise&) = delete;//禁止拷贝赋值

 romise (promise&& x) noexcept;//具备移动语义

 ~promise();//和~packaged_task()语义一样  

 promise& operator= (promise&& rhs) noexcept;//移动赋值，rhs不再有共享状态

 promise& operator= (const promise&) = delete;  

 future<T> get_future();//返回一个future和共享状态关联，可以通过此future获取共享状态的值或异常，该函数只能被调用一次  

 void set_value (const T& val);//设置共享状态的值

 void set_value (const T& val);

 void promise<R&>::set_value (R& val);   // when T is a reference type (R&)

 void promise<void>::set_value (void);   // when T is void  

 void set_exception (exception_ptr p);//设置异常指针p到共享状态中，若状态关联的future::get()会获得该异常(并解除阻塞)  

 void set_value_at_thread_exit (const T& val);//和packaged_task::make_ready_at_thread_exit()语义一样

 void set_value_at_thread_exit (T&& val);

 void promise<R&>::set_value_at_thread_exit (R& val);     // when T is a reference type (R&)

 void promise<void>::set_value_at_thread_exit (void);     // when T is void  

 void set_exception_at_thread_exit (exception_ptr p);//设置异常到共享状态中，但是在线程结束时才使共享状态就绪  

 void swap (promise& x) noexcept;//交换两个promise对象的共享状态  

 shared_future() noexcept;

 shared_future (const shared_future& x);

 shared_future (shared_future&& x) noexcept;

 shared_future (future<T>&& x) noexcept;

 下面的成员函数和future差不多：

 operator=

    赋值操作符，与 std::future 的赋值操作不同，std::shared_future 除了支持 move 赋值操作外，还支持普通的赋值操作。

 get

    获取与该 std::shared_future 对象相关联的共享状态的值（或者异常）。

 valid

    有效性检查。

 wait

    等待与该 std::shared_future 对象相关联的共享状态的标志变为 ready。

 wait_for

    等待与该 std::shared_future 对象相关联的共享状态的标志变为 ready。（等待一段时间，超过该时间段wait_for 返回。）

 wait_until

    等待与该 std::shared_future 对象相关联的共享状态的标志变为 ready。（在某一时刻前等待，超过该时刻 wait_until 返回。）  

 std::mutex m;

 std::deque<std::packaged_task<void()> > tasks;

 bool gui_shutdown_message_received();

 void get_and_process_gui_message();

 void gui_thread()

 {

    while(!gui_shutdown_message_received())//不断获取用户任务

    {

       get_and_process_gui_message();

       std::packaged_task<void()> task;

       {

           std::lock_guard<std::mutex> lk(m);

           if(tasks.empty())

               continue;

           task=std::move(tasks.front());//

           tasks.pop_front();

       }

       task();

    }

 }

 std::thread gui_bg_thread(gui_thread);

 template<typename Func>

 std::future<void> post_task_for_gui_thread(Func f)//添加任务

 {

    std::packaged_task<void()> task(f);

    std::future<void> res=task.get_future();

    std::lock_guard<std::mutex> lk(m);

    tasks.push_back(std::move(task));//

    return res;

 }