C++异步编程：如何不等待future结果继续执行代码？

嘿，从Python的await切换到C的异步编程，确实会有点水土不服——毕竟Python的异步模型是协作式的，而C的std::future默认要你主动get()或者wait()才会拿到结果，还会阻塞当前线程。如果你想要「扔出去一个任务自己跑，主线程继续干别的」，其实有好几种实用的实现方式，我给你捋捋最常用的几个：

1. 最简单的“fire-and-forget”：std::thread + detach #

如果你的任务完全不需要和主线程交互，也不用关心它什么时候结束，直接用std::thread创建线程然后detach就行——这是最直接的方式：

#include <thread>

void background_task() {
    // 这里写你要异步执行的代码，比如耗时的IO、计算逻辑
}

int main() {
    // 启动后台任务，直接detach，主线程瞬间继续往下走
    std::thread(background_task).detach();

    // 主线程正常执行自己的逻辑，完全不会被阻塞
    do_something_else();

    return 0;
}

⚠️ 注意：detach之后，你就没法再控制这个线程了，也没法捕获它抛出的异常，所以只适合完全不需要后续交互的“一次性”任务。

2. 灵活可控的方案：std::async + 保留future #

如果你之后可能需要检查任务状态，或者不想完全“撒手不管”，可以把std::async返回的std::future保存起来，主线程继续执行，等你需要的时候再处理结果（或者永远不处理，让future在程序结束时自动等待任务完成）：

#include <future>
#include <vector>

// 用一个全局/生命周期足够长的容器来存future，避免临时对象析构时阻塞
std::vector<std::future<void>> background_tasks;

void background_task() {
    // 异步任务逻辑
}

int main() {
    // 指定std::launch::async强制在新线程执行任务，避免默认策略的延迟执行
    background_tasks.emplace_back(std::async(std::launch::async, background_task));

    // 主线程该干嘛干嘛，完全不阻塞
    do_something_else();

    // 如果之后需要等待所有任务完成，可以遍历容器统一wait
    for (auto& fut : background_tasks) {
        fut.wait();
    }

    return 0;
}

这种方式比detach线程更安全，因为你可以随时跟踪任务状态，也能在合适的时机等待任务完成。

3. 最接近Pythonawait的体验：C++20协程 #

如果你用的是C++20及以上版本，协程可以让你写出和Python异步风格几乎一致的代码，而且不会阻塞主线程（前提是你的任务是异步可等待的，比如异步IO操作）。

举个简单的协程示例：

#include <coroutine>
#include <iostream>

// 定义一个简单的可等待对象，模拟异步任务
struct AsyncTask {
    struct promise_type {
        AsyncTask get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

AsyncTask background_task() {
    std::cout << "Background task started\n";
    // 模拟异步操作，这里可以替换成真实的非阻塞逻辑（比如Boost.Asio的异步IO）
    // co_await some_async_operation();
    std::cout << "Background task finished\n";
    co_return;
}

int main() {
    // 启动协程任务，主线程不会阻塞，直接继续执行
    auto task = background_task();

    // 主线程的正常逻辑
    std::cout << "Main thread is doing something else\n";

    return 0;
}

实际项目中，你可能会用到成熟的协程库（比如Boost.Asio的协程支持），但核心思想和Python的await一致——协程会在异步操作的地方挂起，主线程可以处理其他任务，等异步操作完成后再恢复协程执行。

4. 高并发场景首选：线程池 #

如果你的程序需要频繁启动大量异步任务，直接创建线程的开销会很大，这时候用线程池是更高效的选择。你可以自己实现一个简单的线程池，或者用现成的第三方库：

// 简化版线程池实现示例
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            threads.emplace_back([this]() {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(mtx);
                        cv.wait(lock, [this]() { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    // 提交任务到线程池
    template<typename F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(mtx);
            tasks.emplace(std::forward<F>(f));
        }
        cv.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();
        for (auto& thread : threads) {
            thread.join();
        }
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex mtx;
    std::condition_variable cv;
    bool stop = false;
};

int main() {
    ThreadPool pool(4); // 创建包含4个工作线程的线程池

    // 提交异步任务，主线程立即返回，任务在线程池的空闲线程中执行
    pool.enqueue([]() {
        // 耗时的异步任务逻辑
    });

    // 主线程继续执行后续代码
    do_something_else();

    return 0;
}

线程池会复用现有线程，避免频繁创建销毁线程的开销，非常适合高并发的场景。

内容的提问来源于stack exchange，提问作者aja