C++并行开发10-future其他成员函数、shared_future、atomic

std::future的其他成员函数

1. std::future_status

#include <iostream>
#include <thread>
#include <algorithm>
#include <vector>
#include <list>
#include <mutex>
#include <future>   //引入std::future头文件
using namespace std;

int my_thread() {  //线程入口函数
    cout << "mythread start" << " threadid is = " << std::this_thread::get_id() << endl;
    std::chrono::milliseconds dura(5000);  //休息了5s
    std::this_thread::sleep_for(dura);
    cout << "over " << endl;
    return 5;
}

int main()
{
    //一、feature其他成员函数
    cout << "main " << "thread id is " << std::this_thread::get_id() << endl;
    std::future<int> result = std::async(my_thread);  //async:异步; 

    cout << "continue " << endl;

    //枚举类型
    std::future_status status = result.wait_for(std::chrono::seconds(6)); //等待1s
    if (status == std::future_status::timeout) {
        //超时，表示线程还没有结束完
        cout << "线程还没有执行完， 超时" << endl;
    }
    else if(status == std::future_status::ready){
        //表示线程成功返回
        cout << "线程成功返回" << endl;
        cout << result.get() << endl;
    }
    else if (status == std::future_status::deferred) {
        //如果    std::future<int> result = std::async(std::launch::deferred, my_thread);  //async:异步; 
        cout << "线程被延迟执行" << endl;
        cout << result.get() << endl;
    }

    cout << "主线程结束 " << endl;
}

std::shared_future

std::future get是一个左移操作，所以只能有一个get() 可以将future转化为shared_future，使得可以多次get()

#include <iostream>
#include <thread>
#include <algorithm>
#include <vector>
#include <list>
#include <mutex>
#include <future>   //引入std::future头文件
using namespace std;

// 三、 std::promise, 类模板
// 我们能够在某个线程中给它赋值，然后再在其他线程中把这个值取出来

void mythread(std::promise<int>& temp, int calc) {
    // 做一些运算
    calc++;
    calc *= 10;

    std::chrono::milliseconds dura(5000);
    std::this_thread::sleep_for(dura);

    int result = calc;
    temp.set_value(result); //结果已经保存到了temp中
}


void mythread2(std::shared_future<int>& temp) {
    auto result = temp.get();  //std::future get是一个左移操作，所以只能有有一个get 
    result = temp.get();  
    result = temp.get();   //std::shared_future可以多次定义

    cout << "mythread2 result is" << result << endl;
}
int main()
{
    std::promise<int> myprom;
    std::thread t1(mythread, std::ref(myprom), 180);
    t1.join();

    //获取结果
    std::future<int> fu1 = myprom.get_future();  //promise 和 future绑定，用于获取线程返回值
    //auto result = fu1.get();
    fu1.valid(); //判断fu1里面是否有有效值
    std::shared_future<int> share_res(std::move(fu1));  //执行完毕后，share_res有值了
    //以下都可以变成shared_future
    //std::shared_future<int> share_res = std::move(fu1);
    //std::shared_future<int> share_res(fu1.share()); 

    std::thread t2(mythread2, std::ref(share_res));
    t2.join();

    cout << "主线程结束 " << endl;
}

atomic

两个线程同时对某一个数进行连续加是不安全的

#include <iostream>
#include <thread>
#include <algorithm>
#include <vector>
#include <list>
#include <mutex>
#include <future>   //引入std::future头文件
using namespace std;

int g_value = 0;

void my_thread() {
    for (int i = 0; i < 1000000; i++) {
        g_value++;
    }
}

int main() {
    thread t1(my_thread);
    thread t2(my_thread);

    t1.join();
    t2.join();
    cout << "value is " << g_value << endl;

    return 0;
}

void my_thread() {
    for (int i = 0; i < 1000000; i++) {
        g_mymutex.lock();
        g_value++;
        g_mymutex.unlock();
    }
}

锁完之后是正常的。 原子操作可以理解成一种多线程中不会被打断的程序执行片段。 互斥量一般针对的是一段代码；原子操作一般针对于某一个变量。
原子操作一般都是指不可分割的操作,一般用于计数中进行使用

std::atomic<int> g_value = 0; //原子操作

void my_thread() {
    for (int i = 0; i < 1000000; i++) {
        //g_mymutex.lock();
        g_value++;
        //g_mymutex.unlock();
    }
}