C++ 异步编程脉络与示例

#include <iostream>
#include <thread>
#include <functional>

// 异步操作函数，接受一个回调函数作为参数
void asyncOperation(std::function<void(int)> callback) {
    std::thread([callback]() {
        std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
        callback(42); // 异步操作完成，调用回调函数
    }).detach(); // 分离线程
}

int main() {
    // 调用异步操作，并传递回调函数
    asyncOperation([](int result) {
        std::cout << "Result: " << result << std::endl;
    });

    std::this_thread::sleep_for(std::chrono::seconds(3)); // 等待异步操作完成
    return 0;
}

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

// 异步操作函数
int asyncOperation() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    return 42;
}

int main() {
    // 启动异步任务，并获取 future 对象
    std::future<int> result = std::async(std::launch::async, asyncOperation);
    
    std::cout << "Waiting for result..." << std::endl;
    
    // 获取异步操作的结果
    std::cout << "Result: " << result.get() << std::endl;
    
    return 0;
}

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

// 异步操作函数，接受一个 std::promise 对象
void asyncOperation(std::promise<int>& prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    prom.set_value(42); // 设置异步操作的结果
}

int main() {
    // 创建 std::promise 对象
    std::promise<int> promise;

    // 获取与 promise 关联的 std::future 对象
    std::future<int> future = promise.get_future();

    // 启动一个线程执行异步操作，并传递 std::promise 对象
    std::thread t(asyncOperation, std::ref(promise));

    // 等待异步操作完成，并获取结果
    std::cout << "Waiting for result..." << std::endl;
    int result = future.get(); // 这会阻塞直到结果可用
    std::cout << "Result: " << result << std::endl;

    // 等待线程完成
    t.join();

    return 0;
}

#include <iostream>
#include <coroutine>
#include <thread>
#include <chrono>

// 自定义的返回类型
struct Task {
    struct promise_type {
        Task get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };
};

Task asyncOperation() {
    std::cout << "Start async operation..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    std::cout << "Async operation completed." << std::endl;
    co_return;
}

int main() {
    asyncOperation();
    std::this_thread::sleep_for(std::chrono::seconds(3)); // 等待异步操作完成
    return 0;
}