1 // future example
 2 #include // std::cout
 3 #include // std::async, std::future
 4 #include // std::chrono::milliseconds
 5 
 6 // a non-optimized way of checking for prime numbers:
 7 bool is_prime (int x) {
 8   for (int i=2; iif (x%i==0) return false;
 9   return true;
10 }
11 
12 int main ()
13 {
14   // call function asynchronously:
15   std::futurebool> fut = std::async (is_prime,444444443); 
16 
17   // do something while waiting for function to set future:
18   std::cout "checking, please wait";
19   std::chrono::milliseconds span (100);
20   while (fut.wait_for(span)==std::future_status::timeout)
21     std::cout ‘.‘  std::flush;
22 
23   bool x = fut.get();     // retrieve return value
24 
25   std::cout "\n444444443 " "is":"is not") " prime.\n";
26 
27   return 0;
28 }

 1 #include  2 #include  3 using namespace std;
 4 class A {
 5 public:
 6     int mythread(int mypar) {
 7         cout  endl;
 8         return mypar;
 9     }
10 };
11  
12  
13 int mythread() {
14     cout "mythread() start" "threadid = "  endl;
15     std::chrono::milliseconds dura(5000);
16     std::this_thread::sleep_for(dura);
17     cout "mythread() end" "threadid = "  endl;
18     return 5;
19 }
20  
21  
22 int main() {
23     A a;
24     int tmp = 12;
25     cout "main" "threadid = "  endl;
26     std::futureint> result1 = std::async(mythread);
27     cout "continue........"  endl;
28     cout get() //阻塞在这里等待mythread()执行完毕，拿到结果
29     
30     //类成员函数
31     std::futureint> result2 = std::async(&A::mythread, &a, tmp); //第二个参数是对象引用才能保证线程里执行的是同一个对象
32     cout get()  endl;
33    //或者result2.wait();
34     cout "good luck"  endl;
35     return 0;
36 }

 1 #include  2 #include  3 using namespace std;
 4  
 5 int mythread() {
 6     cout "mythread() start" "threadid = "  endl;
 7     std::chrono::milliseconds dura(5000);
 8     std::this_thread::sleep_for(dura);
 9     cout "mythread() end" "threadid = "  endl;
10     return 5;
11 }
12  
13  
14 int main() {
15     cout "main" "threadid = "  endl;
16     std::futureint> result1 = std::async(std::launch::deferred ,mythread);
17     cout "continue........"  endl;
18     cout get() //卡在这里等待mythread()执行完毕，拿到结果
19     cout "good luck"  endl;
20     return 0;
21 }

 1 #include  2 #include  3 #include  4 #include  5  
 6 // 线程B
 7 void initiazer(std::promiseint> * promObj)
 8 {
 9     std::cout "Thread B"  std::endl;
10     // set the value at proper time
11     std::this_thread::sleep_for(std::chrono::seconds(3));
12     promObj->set_value(23);
13 }
14  
15 int main()
16 {
17         // 线程A
18     std::promiseint> promiseObj;
19     std::futureint> futureObj = promiseObj.get_future();
20     
21     std::thread th(initiazer, &promiseObj); // 启动线程B
22     
23     // 获取对象的值，该调用在B设置其值后会返回23，在B设置其值前会阻塞
24     std::coutget()  std::endl;
25     
26     th.join();
27     
28     return 0;
29 }
30 
31 //输出23

 1 #include // std::cout, std::endl
 2 #include // std::thread
 3 #include string>   // std::string
 4 #include // std::promise, std::future
 5 #include // seconds
 6 using namespace std::chrono;
 7 //线程B
 8 void read(std::future<:>string> *future) {
 9     // future会一直阻塞，直到有值到来
10     std::cout get()  std::endl;
11 }
12 //线程A
13 int main() {
14     // promise 相当于生产者
15     std::promise<:>string> promise;
16     // future 相当于消费者, 右值构造
17     std::future<:>string> future = promise.get_future();
18     // 另一线程中通过future来读取promise的值
19     std::thread thread(read, &future);
20     // 让read等一会儿:)
21     std::this_thread::sleep_for(seconds(1));
22     // 
23     promise.set_value("hello future");
24     // 等待线程执行完成
25     thread.join();
26 
27     return 0;
28 }
29 // 控制台输: hello future

 1 #include // std::cout
 2 #include // std::packaged_task, std::future
 3 #include // std::chrono::seconds
 4 #include // std::thread, std::this_thread::sleep_for
 5 
 6 // count down taking a second for each value:
 7 int countdown (int from, int to) {
 8     for (int i=from; i!=to; --i) {
 9         std::cout ‘\n‘;
10         std::this_thread::sleep_for(std::chrono::seconds(1));
11     }
12     std::cout "Finished!\n";
13     return from - to;
14 }
15 
16 int main ()
17 {
18     std::packaged_taskint(int,int)> task(countdown); // 设置 packaged_task
19     std::futureint> ret = task.get_future(); // 获得与 packaged_task 共享状态相关联的 future 对象.
20 
21     std::thread th(std::move(task), 10, 0);   //创建一个新线程完成计数任务.
22 
23     int value = ret.get();                    // 等待任务完成并获取结果.
24 
25     std::cout "The countdown lasted for " " seconds.\n";
26 
27     th.join(); 
28     return 0;
29 }

 1 #include  2 #include  3 #include  4 using namespace std;
 5  
 6 int mythread() {
 7     cout "mythread() start" "threadid = "  endl;
 8     std::chrono::milliseconds dura(5000);
 9     std::this_thread::sleep_for(dura);
10     cout "mythread() end" "threadid = "  endl;
11     return 5;
12 }
13 
14 int main() {
15     cout "main" "threadid = "  endl;
16     std::packaged_taskint()> mypt(mythread);
17     std::thread t1(std::ref(mypt));
18     std::futureint> result = mypt.get_future();
19     
20     bool ifcanget = result.valid(); //判断future 中的值是不是一个有效值
21     std::shared_futureint> result_s(result.share()); //执行完毕后result_s里有值，而result里空了
22     //std::shared_future result_s(std::move(result));
23    //通过get_future返回值直接构造一个shared_future对象
24    //std::shared_future result_s(mypt.get_future());
25    t1.join();
26     
27     auto myresult1 = result_s.get();
28     auto myresult2 = result_s.get();
29  
30     cout "good luck"  endl;
31     return 0;
32 }