비동기 프로그래밍

#include <thread>
#include <iostream>
#include <utility>
#include <functional>
#include <future>   // std::async, std::future를 위해
#include <chrono>   // std::chrono::seconds를 위해
#include <string>   // std::string을 위해

// 시간이 오래 걸리는 계산 함수
int calculate_sum(int start, int end) {
    std::cout << "Calculating sum from " << start << " to " << end << " in thread: "
              << std::this_thread::get_id() << std::endl;
    int sum = 0;
    for (int i = start; i <= end; ++i) {
        sum += i;
        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // 작업 시뮬레이션
    }
    std::cout << "Calculation for " << start << "-" << end << " finished.\n";
    return sum;
}

int main() {
    std::cout << "Main thread started (ID: " << std::this_thread::get_id() << ")\n";

    // std::async를 사용하여 calculate_sum 함수를 비동기적으로 실행
    // 기본 정책 (std::launch::async | std::launch::deferred)
    std::future<int> future_sum1 = std::async(calculate_sum, 1, 500);

    // 명시적으로 새로운 스레드에서 실행하도록 지정
    std::future<int> future_sum2 = std::async(std::launch::async, calculate_sum, 501, 1000);

    std::cout << "Main thread continues doing other work...\n";
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 메인 스레드에서 다른 작업 수행

    // future_sum1의 결과를 기다리고 가져옴
    std::cout << "Waiting for future_sum1 result...\n";
    int result1 = future_sum1.get(); // get()은 결과를 받을 때까지 블록
    std::cout << "Result 1: " << result1 << std::endl;

    // future_sum2의 결과를 기다리고 가져옴
    std::cout << "Waiting for future_sum2 result...\n";
    int result2 = future_sum2.get();
    std::cout << "Result 2: " << result2 << std::endl;

    std::cout << "Total sum: " << result1 + result2 << std::endl;
    std::cout << "Main thread finished.\n";

    // 중요: future 객체가 소멸될 때 (예: 스코프를 벗어날 때),
    // async 정책으로 시작된 미완료 작업의 shared state에 대한 마지막 참조를 놓으면
    // 작업 완료를 기다릴 수 있습니다. 모든 future 소멸자가 대기하는 것은 아닙니다.
    // 따라서 명시적으로 get()이나 wait()를 호출하여 제어하는 것이 좋습니다.

    return 0;
}

#include <chrono>
#include <future>
#include <iostream>

int main() {
    int calls = 0;
    auto result = std::async(std::launch::deferred, [&calls] {
        ++calls;
        return 42;
    });
    std::cout << "before=" << calls << '\n';
    auto status = result.wait_for(std::chrono::milliseconds(0));
    std::cout << "deferred="
              << (status == std::future_status::deferred)
              << " calls=" << calls << '\n';
    result.wait();
    std::cout << "after wait=" << calls
              << " valid=" << result.valid() << '\n';
    int value = result.get();
    std::cout << "value=" << value
              << " valid=" << result.valid() << '\n';
}

#include <iostream>
#include <thread>
#include <utility>
#include <functional>
#include <future>   // std::promise, std::future를 위해
#include <string>
#include <chrono>

// 데이터를 준비하고 promise를 통해 전달하는 함수
void prepare_data(std::promise<std::string> prom) {
    std::cout << "Data preparer thread (ID: " << std::this_thread::get_id() << ") started.\n";
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 데이터 준비 시간 시뮬레이션

    std::string data = "Hello from async world!";
    std::cout << "Data preparer: Data prepared.\n";
    prom.set_value(data); // promise를 통해 값을 설정 (future로 전달됨)
    std::cout << "Data preparer: Value set in promise.\n";
}

// 데이터를 기다리고 future를 통해 받는 함수
void consume_data(std::future<std::string>& fut) {
    std::cout << "Data consumer thread (ID: " << std::this_thread::get_id() << ") started.\n";
    std::cout << "Data consumer: Waiting for data...\n";

    try {
        std::string received_data = fut.get(); // future의 get()을 통해 값 블로킹 대기
        std::cout << "Data consumer: Received data: '" << received_data << "'\n";
    } catch (const std::exception& e) {
        std::cerr << "Data consumer: Caught exception: " << e.what() << std::endl;
    }
}

int main() {
    std::cout << "Main thread started (ID: " << std::this_thread::get_id() << ")\n";

    // 1. promise 객체 생성
    std::promise<std::string> data_promise;

    // 2. promise에서 future 객체 얻기
    std::future<std::string> data_future = data_promise.get_future();

    // 3. producer 스레드는 promise를 받아 값을 설정
    std::thread producer_thread(prepare_data, std::move(data_promise)); // promise는 move-only

    // 4. consumer 스레드는 future를 받아 값을 기다림
    std::thread consumer_thread(consume_data, std::ref(data_future)); // future도 move-only이지만,
                                                                       // 여기서는 참조로 전달하여 소유권을 유지

    std::cout << "Main thread doing other tasks...\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));

    producer_thread.join();
    consumer_thread.join();

    std::cout << "Main thread finished.\n";
    return 0;
}

#include <future>
#include <iostream>

int main() {
    std::future<int> result;
    {
        std::promise<int> producer;
        result = producer.get_future();
    }
    try {
        std::cout << result.get() << '\n';
    } catch (const std::future_error& error) {
        std::cout << "broken="
                  << (error.code() == std::make_error_code(
                         std::future_errc::broken_promise)) << '\n';
    }
}

#include <iostream>
#include <thread>
#include <utility>
#include <functional>
#include <future>   // std::packaged_task를 위해
#include <chrono>

int process_heavy_task(int value) {
    std::cout << "Processing heavy task with value " << value << " in thread: "
              << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return value * 2;
}

int main() {
    std::cout << "Main thread started (ID: " << std::this_thread::get_id() << ")\n";

    // 1. packaged_task 객체 생성 (함수를 래핑)
    std::packaged_task<int(int)> task(process_heavy_task);

    // 2. task에서 future 객체 얻기
    std::future<int> result_future = task.get_future();

    // 3. task를 별도의 스레드에서 실행
    std::thread worker_thread(std::move(task), 10); // task는 move-only

    std::cout << "Main thread continues doing other things...\n";
    std::this_thread::sleep_for(std::chrono::seconds(1));

    // 4. 결과를 기다리고 가져옴
    std::cout << "Main thread: Waiting for task result...\n";
    int result = result_future.get();
    std::cout << "Main thread: Task result: " << result << std::endl;

    worker_thread.join(); // worker_thread가 종료될 때까지 대기

    std::cout << "Main thread finished.\n";
    return 0;
}