C++多线程chap3 多线程异步和通信1

这里，只是记录自己的学习笔记。

顺便和大家分享多线程的基础知识。然后从入门到实战。有代码。

知识点来源：

https://edu.51cto.com/course/26869.html

---

Promise 和 Future 的原理，以及演示

//线程异步和通信


/*
//promise 和 future

promise 用于异步传输变量
    std::promise 提供存储异步通信的值，再通过其对象创建的std::future异步获得结果。
    std::promise 只能使用一次。void set_value(_Ty&& _Val)设置传递值，只能调用一次

std::future 提供访问异步操作结果的机制
    get()阻塞等待 promise set_value 的值

*/

#include <iostream>
#include <thread>
#include <future>
#include <string>
using namespace std;

void TestFuture(  promise<string> p){
    cout << "begin TestFuture" << endl;

    this_thread::sleep_for(4s);
    cout << "begin set value" << endl;

    p.set_value("TestFuture value");
    this_thread::sleep_for(4s);

    cout << "end TestFuture" << endl;
}

int main() {
    //异步传输变量存储
    promise<string> p;

    //用来获取线程异步值
    auto future = p.get_future();

    thread th(TestFuture, move(p));

    cout << "begin future.get()" << endl;
    cout << "future get() =" << future.get() << endl;//线程在此处阻塞。等到 调用了 set_value 之后，阻塞取消。
    cout << "end future.get()" << endl;
    th.join();

    //  begin future.get()...线程在此处阻塞。等到 调用了 set_value 之后，阻塞取消。
    //    begin TestFuture
    //    begin set value   
    //    future get() = TestFuture value
    //    end future.get()
    //    end TestFuture


    getchar();
    return 0;
}

packaged_task 异步调用函数打包

ackaged_task 包装函数为一个对象，用于异步调用。其返回值能通过 std::future() 对象访问
与 bind 的区别，可异步调用，函数访问和获取返回值分开调用。

/*
packaged_task 异步调用函数打包

ackaged_task 包装函数为一个对象，用于异步调用。其返回值能通过 std::future() 对象访问
与 bind 的区别，可异步调用，函数访问和获取返回值分开调用。

*/


// 函数指针

#include <iostream>
#include <thread>
#include <future>
#include <string>

using namespace std;

string TestPack(int index) {
    cout << "begin Test Pack" << index << endl;
    this_thread::sleep_for(3s);
    return "Test Pack return ";
}


int main(int argc, char* argv[]) {
    //同步
    {
        //// string(int) 是 TestPack 的函数指针
        //packaged_task<string(int) >  task(TestPack);
        //auto  result = task.get_future();
        //task(100);

        //cout << "begin result get" << endl;
        //cout << "result get: " << result.get() << endl;
        ////result.get()是阻塞的
    }


    //异步
    {
        // string(int) 是 TestPack 的函数指针
        packaged_task<string(int) >  task(TestPack);
        auto  result = task.get_future();
        //task(100);
        thread th(move(task), 102);
        cout << "begin result get " << endl;
        // get()是阻塞，会等待函数返回。。
        cout << "result get: " << result.get() << endl;
        th.join();
    }


    //异步
    {
        // string(int) 是 TestPack 的函数指针
        packaged_task<string(int) >  task(TestPack);
        auto  result = task.get_future();
        //task(100);
        thread th(move(task), 103);
        cout << "begin result get " << endl;

        for (int i = 0; i < 30; i++) {
            if (result.wait_for(100ms) != future_status::ready) {
                continue;
            }
        }
        if (result.wait_for(100ms) == future_status::timeout) {
            cout << "wait result timeout" << endl;
        }
        else{
            cout << "result get: " << result.get() << endl;
        }
        th.join();
    }

    getchar();
    return 0;
}

async
C++ 异步运行一个函数，并返回保有其结果的 std::future

1.launch::deferred 延迟执行，在调用 wait 和 get 时，调用函数代码。
2.launch::async 创建线程（默认）
3.返回的线程函数的返回值类型的std::future<int> (std::future<线程函数的返回值类型>)
4.re.get() 获取结果，会阻塞等待。

/*
async 
C++ 异步运行一个函数，并返回保有其结果的 std::future 

1.launch::deferred 延迟执行，在调用 wait 和 get 时，调用函数代码。
2.launch::async 创建线程（默认）
3.返回的线程函数的返回值类型的std::future<int> (std::future<线程函数的返回值类型>)
4.re.get() 获取结果，会阻塞等待。
*/

#include <iostream>
#include <thread>
#include <future>
#include <string>

using namespace std;

string TestAsync(int index) {
    cout << index<< " begin in TestAsync " << this_thread::get_id() << endl;
    this_thread::sleep_for(2s);
    return "TestAsync string return";
}


int main() {
    //创建异步线程

    {
        //不创建线程，启动异步任务
        //cout << "main thread id: " << this_thread::get_id() << endl;
        //auto future = async(launch::deferred, TestAsync, 100);
        //this_thread::sleep_for(50ms);
        //cout << "begin future get " << endl;
        //cout << "future.get() = " << future.get() << endl;//调用get函数的时候，才开始执行TestAsync方法
        //cout << "end future get " << endl;
    }

    {
        //创建异步线程
        cout << "=======创建异步线程=========mainThreadId:"<<this_thread::get_id() << endl;
        auto future2 = async(TestAsync, 102);
        this_thread::sleep_for(50ms);
        cout << "begin future2 get " << endl;
        cout << "future2.get() = " << future2.get() << endl;
        cout << "end future2 get " << endl;
    }

    getchar();
    return 0;
}