Effective Modern C++ 条款 35：基于任务与基于线程编程的对比与实践

2.2 资源管理的智慧

基于任务的方式之所以优越，关键在于它实现了资源管理的自动化：

1. 避免线程耗尽：当系统线程不足时，std::async 可能选择不创建新线程，而 std::thread 直接抛出异常
2. 防止资源超额：智能调度避免活跃线程数超过硬件支持
3. 优化缓存利用：减少不必要的线程切换带来的缓存失效

考虑一个图像处理应用的例子：

// 基于线程的版本
void processImage(Image img) {
    // 图像处理逻辑
}

std::vector<std::thread> threads;
for (auto& img : images) {
    threads.emplace_back(processImage, img);
    if (threads.size() >= maxThreads) {
        // 必须手动限制
        waitForSomeThreads(threads);
    }
}

// 基于任务的版本
std::vector<std::future<void>> futures;
for (auto& img : images) {
    futures.push_back(std::async(processImage, img)); // 无需担心线程数
}

三、实战案例：Web 服务器中的并发处理

让我们通过一个 Web 服务器请求处理的场景，对比两种方式的实现差异。

3.1 基于线程的实现

void handleRequest(Request req) {
    try {
        auto result = processRequest(req);
        sendResponse(result);
    } catch (...) {
        logError("Request failed");
    }
}

void serverLoop() {
    while (true) {
        auto req = acceptRequest();
        std::thread(handleRequest, req).detach(); // 危险！可能线程耗尽
    }
}

这种实现的问题：

• 无限制创建线程可能导致系统崩溃
• 异常处理复杂且不统一
• 难以获取处理结果

3.2 基于任务的实现

std::future<Response> handleRequestAsync(Request req) {
    return std::async([req] { return processRequest(req); }); // 异常会自动捕获
}

void serverLoop() {
    std::vector<std::future<Response>> pendingRequests;
    while (true) {
        auto req = acceptRequest();
        pendingRequests.push_back(handleRequestAsync(req));
        // 定期清理已完成的任务
        pendingRequests.erase(
            std::remove_if(pendingRequests.begin(), pendingRequests.end(), [](auto& fut) {
                return is_ready(fut);
            }),
            pendingRequests.end());
    }
}

优势对比表：

四、何时使用基于线程的编程？

尽管基于任务的方式在大多数情况下更优，但某些特定场景仍需直接使用 std::thread：

1. 高度优化的专用系统：如高频交易系统需要精确控制
2. 实现标准库未提供的机制：如特定平台的线程池
3. 需要底层线程控制：如设置线程优先级、亲和性等

std::thread t(highPriorityTask);
setThreadPriority(t.native_handle(), HIGH);

五、最佳实践指南

• 注意启动策略：必要时使用 std::launch::async

auto fut = std::async(std::launch::async, immediateTask);

• 批量任务管理：结合容器管理多个 future

std::vector<std::future<Result>> futures;
for (auto& item : items) {
    futures.push_back(std::async(process, item));
}

• 明确异常处理：利用 future 自动传播异常的特性

try {
    auto result = future.get();
} catch (const std::exception& e) {
    // 统一处理异常
}

• 默认使用 std::async：让标准库处理线程管理细节

auto future = std::async(doWork); // 默认启动策略

结语：选择的力量

正如 Scott Meyers 在《Effective Modern C++》中所强调的，基于任务的编程不仅减少了代码量，更重要的是将开发者从繁琐的线程管理细节中解放出来。这种抽象的力量，正是现代 C++ 并发编程的精髓所在。

记住这个简单的选择原则：

当你需要并发时，首先考虑任务而非线程。让标准库成为你的并发伙伴，而非自己重新发明轮子。

通过采用基于任务的编程范式，你将写出更简洁、更安全、更可能利用未来并发优化的代码，这正是现代 C++ 开发者应当追求的目标。