十、future其他成员函数、shared_future、atomic（原子操作）

一、

 int mythread(){
     cout<<"thread"<<endl;
     std::chrono::milliseconds dura();//5秒钟
     std::this_thread::sleep_for(dura);//休息5秒钟
     return ;
 }

 int main(){
     std::future<int> result = std::async(mythread);

     //是个枚举类型有ready,timeout,deferred
     std::future_status status = result.wait_for(std::chrono::second());//等1秒，
     if(status==std::future_status::timeout){
         //线程要执行5秒，这里只等待1秒，希望你返回，你没有返回那么status 是 timeout
     }
     else if(status==std::future_status::timeout){
         //表示线程成功返回
         cout << result.get() <<endl;
     }
     else if(status==std::future_status::deffered){
         //如果saync第一个参数设置这个deffered，这个线程被延迟执行
         //遇到get线程才会执行，mythread会在主线程中执行（相当于在主线程中的一个函数调用），就不是真正意义上的子线程了
         cout<<res.get()<<endl;
     }
 }

shared_future

类模板，使用get函数时就是复制了，第二次使用get还会成功

 int mythread(){
     cout<<"thread"<<endl;
     std::chrono::milliseconds dura();//5秒钟
     std::this_thread::sleep_for(dura);//休息5秒钟
     return ;
 }

 int main(){
     std::future<int> result = mypt.get_future();
     std::shared_future<int> result_s(std::move(result));//move变成右值,将result 过渡给了result_s，result里就空了，移动语义
     //不能直接用result_s(result),会报错,接受的是一个右值属性的，所以要用move变成右值属性
     //这样也可以：std::shared_future<int> result_s(result.share());
     ifcanget = result_s.valid();//true or false

 }    

原子操作

互斥量：多线程编程中，保护共享数据

锁：操作共享数据，开锁

有两个线程，对一个变量进行操作，这个线程读该变量值，另一个线程往这个线程中写值。

A线程： tmp = bbb;//bbb是多线程中共享的变量

B线程： bbb = 6;

注意：B中的赋值语句，会有多个操作步骤（汇编中可能有n多行汇编代码），有可能你执行到汇编代码第x行的时候线程B就切出去了，这个时候A读到的变量就是B赋值过程中的中间值。

解决这个问题可以用互斥量，但是这样效率会很慢。

使用原子操作就能够解决这个问题，类似于锁，但是效率比互斥量高很多。保证赋值这个操作执行完。

可以把原子操作理解为一种，不需要互斥量加锁（无锁）技术的多线程并发变成方式

也可以理解为在多线程中，不会被打断程序执行片断，无锁操作，比互斥量效率高。

一般互斥量针对一个代码段（几行代码），而原子操作针对一个变量，而不是代码段。

原子操作：指不可分割的操作，也就是说这种操作状态要么是完成的，要么是没完成的，不能出现半完成状态。

std::atomic类模板，用来封装某个类型的值

 std::automic<int> g_mycount = ;//封装了一个类型为int的对象，可以像操作一个int变量一样来操作g_mycount

                 //g_mycount++；是一个原子操作，每一次的操作不会被打断

 void mythread(){
     std::chrono::milliseconds dura();//
     while(g_ifend==false){
         std::this_thread::sleep_for(dura);//没一秒钟判断一次g_ifend
     }
     cout<<"结束"<<endl;
     return;
 }

 int main(){
     thread my1(mythread);
     thread my2(mythread);
     std::chrono::milliseconds dura();
     std::this_thread::sleep_for(dura);
     g_ifend = true;
     my1.join();
     my2.join();
     cout<<"end"<<endl;
 }