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

一、

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

int main(){
    std::future<int> result = std::async(mythread);
    
    //是个枚举类型有ready,timeout,deferred
    std::future_status status = result.wait_for(std::chrono::second(1));//等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(5000);//5秒钟
    std::this_thread::sleep_for(dura);//休息5秒钟
    return 5;
}

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 = 0;//封装了一个类型为int的对象，可以像操作一个int变量一样来操作g_mycount

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

void mythread(){
    std::chrono::milliseconds dura(1000);//1
    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(5000);
    std::this_thread::sleep_for(dura);
    g_ifend = true;
    my1.join();
    my2.join();
    cout<<"end"<<endl;
}