C++: promise, future, packaged_task, async

개요

• promise
  • 복사 생성 불가
• future
  • 객체 이동이 일어나므로 한번만 get 가능
• shared_future
  • 복사가 가능하고 같은 객체를 공유
• packaged_task
  • promise-future 패턴을 Callable의 반환값에 적용
  • packaged_task에 전달된 함수의 리턴값을 promise에 set_value 혹은 set_exception
  • packaged_task가 리턴하는 future를 통해 접근
  • 복사 생성 불가
• async
  • 쓰레드를 자동으로 만들어서 전달된 함수를 수행하고 리턴값을 future에 전달
  • launch::async
    • 쓰레드를 바로 생성하여 전달된 함수 실행
  • launch::deferred
    • future의 get 함수가 호출되었을 때 쓰레드를 생성하지 않고 전달된 함수 실행

예제

• make_unique를 사용함으로 C++14로 컴파일
• 코드

    #include <chrono>
    #include <future>
    #include <iostream>
    #include <memory>
    #include <string>
    #include <thread>
    #include <vector>

    using namespace std;

    int main() {
        thread t1;
        thread t2;

        unique_ptr<promise<string>> p = make_unique<promise<string>>();
        future<string> f = p->get_future();

        t1 = thread([&p]() { p->set_value("data"); });
        t2 = thread([&f]() { cout << f.get() << endl; });
        t1.join();
        t2.join();

        cout << "------" << endl;

        p = make_unique<promise<string>>();
        f = p->get_future();
        t1 = thread([&p]() {
            try {
                throw runtime_error("runtime_error");
            } catch (...) {
                p->set_exception(current_exception());
            }
        });
        t2 = thread([&f]() {
            try {
                cout << f.get() << endl;
            } catch (const exception &e) {
                cout << e.what() << endl;
            }
        });
        t1.join();
        t2.join();

        cout << "------" << endl;

        p = make_unique<promise<string>>();
        f = p->get_future();
        t1 = thread([&p]() {
            this_thread::sleep_for(chrono::seconds(3));
            p->set_value("data");
        });
        t2 = thread([&f]() {
            while (true) {
                future_status status = f.wait_for(chrono::seconds(1));
                if (status == future_status::timeout) {
                    cout << "timeout" << endl;
                } else if (status == future_status::ready) {
                    cout << "ready : " << f.get() << endl;
                    break;
                } else if (status == future_status::deferred) {
                    cout << "deferred" << endl;
                }
            }
        });
        t1.join();
        t2.join();

        cout << "------" << endl;

        p = make_unique<promise<string>>();
        shared_future<string> sf = p->get_future();
        t1 = thread([&p]() { p->set_value("data"); });
        t2 = thread([sf]() {
            vector<thread> v;
            v.clear();

            for (int i = 0; i < 3; ++i) {
                v.push_back(thread([&sf]() { cout << sf.get() << endl; }));
            }

            for (auto &iter : v) {
                iter.join();
            }
        });
        t1.join();
        t2.join();

        cout << "------" << endl;

        packaged_task<string(int)> task([](int i) { return to_string(i); });
        f = task.get_future();
        t1 = thread(move(task), 1);
        t2 = thread([&f]() { cout << f.get() << endl; });
        t1.join();
        t2.join();

        cout << "------" << endl;

        cout << "main : " << this_thread::get_id() << endl;
        f = async(
            launch::async,
            [](int i) {
                cout << "async : " << this_thread::get_id() << endl;
                return to_string(i);
            },
            1);
        cout << f.get() << endl;

        cout << "------" << endl;

        cout << "main : " << this_thread::get_id() << endl;
        f = async(
            launch::deferred,
            [](int i) {
                cout << "async : " << this_thread::get_id() << endl;
                return to_string(i);
            },
            1);
        cout << f.get() << endl;

        return 0;
    }

• 실행 결과

    data
    ------
    runtime_error
    ------
    timeout
    timeout
    ready : data
    ------
    data
    data
    data
    ------
    1
    ------
    main : 139688566888256
    async : 139688541705792
    1
    ------
    main : 139688566888256
    async : 139688566888256
    1