构建异步C++应用：libcpr/cpr的future与promise应用

构建异步C++应用：libcpr/cpr的future与promise应用

【免费下载链接】cpr 项目地址: https://gitcode.com/gh_mirrors/cpr/cpr

你是否还在为C++网络请求阻塞主线程而烦恼？是否想让应用在处理HTTP通信时保持流畅响应？本文将带你一文掌握libcpr/cpr库的异步编程范式，通过future与promise机制实现高效非阻塞网络操作，让你的应用性能提升300%。

读完本文你将获得：

• 掌握cpr异步接口的核心使用方法
• 学会用future/promise处理异步结果
• 实现可取消的网络请求
• 线程池优化技巧与最佳实践

异步编程基础：从阻塞到非阻塞

在传统同步编程模型中，网络请求会阻塞当前线程执行，导致界面卡顿或服务响应延迟。而异步编程通过"发起请求-继续执行-结果回调"的模式，让程序在等待IO操作时仍能处理其他任务。

libcpr/cpr作为基于libcurl的C++ HTTP客户端库，提供了完善的异步支持。其核心异步组件位于include/cpr/async.h和include/cpr/async_wrapper.h，通过C++11标准的future/promise机制实现结果传递。

cpr异步架构解析

cpr的异步实现基于三层架构设计：

核心组件解析

1. GlobalThreadPool：全局线程池单例，管理异步任务的执行线程。默认配置可通过include/cpr/async.h中的startup()方法调整：

// 初始化线程池，设置最小2个、最大8个工作线程，最大空闲时间30秒
cpr::async::startup(2, 8, std::chrono::milliseconds(30000));

2. AsyncWrapper：异步结果包装器，封装了std::future并提供取消功能。其模板参数isCancellable控制是否支持取消操作，如include/cpr/async_wrapper.h第19行定义：

template <typename T, bool isCancellable = false>
class AsyncWrapper { ... };

3. Cancellation机制：通过原子布尔量跟踪取消状态，实现请求的优雅中止。如include/cpr/async_wrapper.h第110-119行的Cancel()方法：

CancellationResult Cancel() {
    if constexpr (!isCancellable) {
        return CancellationResult::invalid_operation;
    }
    if (!future.valid() || is_cancelled->load()) {
        return CancellationResult::invalid_operation;
    }
    is_cancelled->store(true);
    return CancellationResult::success;
}

快速上手：异步GET请求实现

下面通过一个完整示例展示如何使用cpr实现异步HTTP GET请求：

#include <iostream>
#include <cpr/cpr.h>
#include <cpr/async.h>

int main() {
    // 初始化线程池
    cpr::async::startup(4);
    
    // 发起异步GET请求
    auto future = cpr::async([]() {
        return cpr::Get(cpr::Url{"https://api.example.com/data"});
    });
    
    // 执行其他任务...
    std::cout << "请求已发送，正在处理其他任务..." << std::endl;
    
    // 获取结果（阻塞直到完成）
    try {
        cpr::Response response = future.get();
        if (response.status_code == 200) {
            std::cout << "请求成功，响应内容：" << response.text << std::endl;
        } else {
            std::cout << "请求失败，状态码：" << response.status_code << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "请求异常：" << e.what() << std::endl;
    }
    
    // 清理线程池
    cpr::async::cleanup();
    return 0;
}

高级应用：可取消的异步请求

cpr提供了请求取消功能，特别适合处理用户主动中断或超时场景。以下是实现可取消请求的示例：

// 创建可取消的异步请求
auto cancellable_future = cpr::AsyncWrapper<cpr::Response, true>(
    std::async(std::launch::async, []() {
        return cpr::Get(cpr::Url{"https://api.example.com/large-data"});
    }),
    std::make_shared<std::atomic_bool>(false)
);

// 超时检查线程
std::thread timeout_thread([&]() {
    std::this_thread::sleep_for(std::chrono::seconds(5));
    auto result = cancellable_future.Cancel();
    if (result == cpr::CancellationResult::success) {
        std::cout << "请求已取消" << std::endl;
    }
});

// 等待结果
if (cancellable_future.IsCancelled()) {
    std::cout << "请求已被取消" << std::endl;
} else {
    try {
        cpr::Response response = cancellable_future.get();
        std::cout << "请求成功，响应长度：" << response.text.size() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "请求异常：" << e.what() << std::endl;
    }
}

timeout_thread.join();

线程池优化策略

合理配置线程池参数对异步性能至关重要。cpr的GlobalThreadPool提供了灵活的配置选项：

参数	默认值	建议设置	影响
最小线程数	2	CPU核心数	保证基础并发能力
最大线程数	8	CPU核心数×2	限制资源占用
最大空闲时间	30秒	10-60秒	平衡响应速度与资源消耗

配置示例：

// 根据系统CPU核心数动态配置
unsigned int cores = std::thread::hardware_concurrency();
cpr::async::startup(cores, cores * 2, std::chrono::seconds(30));

错误处理最佳实践

异步操作中的错误处理需要特别注意，以下是推荐的错误处理模式：

auto future = cpr::async([]() -> cpr::Response {
    try {
        return cpr::Get(cpr::Url{"https://unreliable-api.com/data"},
                       cpr::Timeout{5000});
    } catch (const cpr::TimeoutException& e) {
        std::cerr << "请求超时：" << e.what() << std::endl;
        return cpr::Response{cpr::ErrorCode{cpr::ErrorCodes::OPERATION_TIMEDOUT}};
    } catch (const std::exception& e) {
        std::cerr << "请求失败：" << e.what() << std::endl;
        return cpr::Response{cpr::ErrorCode{cpr::ErrorCodes::CONNECTION_FAILURE}};
    }
});

// 处理结果
cpr::Response response = future.get();
if (response.error.code != cpr::ErrorCodes::OK) {
    // 错误处理逻辑
}

实际应用案例：并行API请求

在需要获取多个API数据时，并行异步请求可以显著提升性能：

// 并行发起多个请求
auto future1 = cpr::async([]() { return cpr::Get(cpr::Url{"https://api.example.com/data1"}); });
auto future2 = cpr::async([]() { return cpr::Get(cpr::Url{"https://api.example.com/data2"}); });
auto future3 = cpr::async([]() { return cpr::Get(cpr::Url{"https://api.example.com/data3"}); });

// 等待所有请求完成
auto response1 = future1.get();
auto response2 = future2.get();
auto response3 = future3.get();

// 合并处理结果
process_responses({response1, response2, response3});

总结与展望

通过cpr的异步接口，我们可以轻松构建高效的非阻塞C++网络应用。核心要点包括：

1. 使用cpr::async()发起异步请求，通过future获取结果
2. 利用AsyncWrapper实现请求取消功能
3. 合理配置线程池参数优化性能
4. 完善的错误处理确保应用稳定性

随着C++20协程的普及，未来cpr可能会提供更直观的异步编程模型。现在就尝试将本文介绍的异步技术应用到你的项目中，体验非阻塞网络编程的魅力！

点赞收藏本文，关注更多C++异步编程技巧。下期我们将探讨cpr与协程的结合应用，敬请期待！

【免费下载链接】cpr 项目地址: https://gitcode.com/gh_mirrors/cpr/cpr