async_simple：轻量级 C++ 异步协程框架

2.2.安装 async_simple

async_simple 支持两种安装方式：源码编译安装（推荐，灵活可控）和 包管理器安装（仅部分系统支持）。

方式 1：源码编译安装（跨平台通用）

这是最稳定的安装方式，支持自定义编译选项（如静态库 / 动态库、C++20 支持等）。

步骤 1：克隆源码

git clone -b main --single-branch --depth 1 https://github.com/alibaba/async_simple.git
cd async_simple
mkdir build
cd build
cmake .. -DASYNC_SIMPLE_ENABLE_TESTS=OFF -DASYNC_SIMPLE_BUILD_DEMO_EXAMPLE=OFF -DASYNC_SIMPLE_ENABLE_ASAN=OFF
cmake --build .
cmake --install . # --prefix ./user_defined_install_path

• --branch v0.10.0：指定版本（可在 GitHub Releases 查看最新版本）。
• --depth 1：仅克隆最新提交，减少下载体积。

步骤 2：配置 CMake

创建构建目录并配置编译选项：

mkdir build && cd build
# 基础配置（默认静态库、关闭测试、C++17）
cmake .. \
  -DCMAKE_BUILD_TYPE=Release \
  -DASYNC_SIMPLE_BUILD_TEST=OFF \
  -DASYNC_SIMPLE_BUILD_EXAMPLES=OFF \
  -DCMAKE_INSTALL_PREFIX=/usr/local \
  -DCMAKE_CXX_STANDARD=17

可选编译选项（按需添加）

cmake .. \
  -DCMAKE_BUILD_TYPE=Release \
  -DASYNC_SIMPLE_BUILD_TEST=OFF \
  -DCMAKE_CXX_STANDARD=20 \
  -DASYNC_SIMPLE_ENABLE_CPP20=ON \
  -DBUILD_SHARED_LIBS=ON \
  -DCMAKE_INSTALL_PREFIX=/usr/local

安装结果验证

安装完成后，/usr/local（或自定义路径）下会生成以下文件：

/usr/local/
├── include/async_simple/ # 头文件
├── lib/ # 库文件（.a 静态库 / .so 动态库）
└── lib/cmake/async_simple/ # CMake 配置文件（用于项目集成）

方式 2：包管理器安装（便捷但版本可能滞后）

Windows（vcpkg）：

vcpkg install async-simple

macOS（Homebrew）：

brew install async-simple

2.3.项目集成（CMake 示例）

async_simple 安装后，通过 CMake 可快速集成到你的项目中。以下是完整示例：

创建项目结构

my_async_project/
├── CMakeLists.txt # 项目配置文件
└── main.cpp # 测试代码

编写 CMakeLists.txt

# 指定 CMake 最低版本
cmake_minimum_required(VERSION 3.10)
# 项目名称与 C++ 标准
project(my_async_project)
set(CMAKE_CXX_STANDARD 17) # 匹配安装时的 C++ 标准
set(CMAKE_CXX_STANDARD_REQUIRED ON) # 查找 async_simple 库（自动找到头文件和库文件）
find_package(async_simple REQUIRED) # 创建可执行文件
add_executable(my_async_app main.cpp) # 链接 async_simple 库（静态库/动态库自动适配）
target_link_libraries(my_async_app PRIVATE async_simple::async_simple) # （可选）若启用了 C++20 协程，添加编译器选项
if(CMAKE_CXX_STANDARD GREATER_EQUAL 20)
  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    target_compile_options(my_async_app PRIVATE -fcoroutines)
  elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    target_compile_options(my_async_app PRIVATE -fcoroutines-ts)
  endif()
endif()

编写测试代码（main.cpp）

#include <async_simple/coro/Lazy.h>
#include <async_simple/executor/SimpleExecutor.h>
#include <async_simple/syncAwait.h>
#include <iostream>
using namespace async_simple;
using namespace async_simple::coro;

// 异步任务：模拟 IO 操作
Lazy<int> asyncAdd(int a, int b) {
  co_await sleep(500); // 异步睡眠 500ms（不阻塞线程）
  co_return a + b;
}

int main() {
  // 创建单线程执行器
  executor::SimpleExecutor ex(1);
  // 同步等待异步任务结果
  int result = syncAwait(asyncAdd(10, 20).via(&ex));
  std::cout << "10 + 20 = " << result << std::endl; // 输出：10 + 20 = 30
  return 0;
}

编译运行项目

# 创建构建目录
mkdir build && cd build
# 配置 CMake（若 async_simple 安装在非默认路径，需指定 CMAKE_PREFIX_PATH）
cmake ..
# 若自定义安装路径（如 ~/local），需添加：
# cmake .. -DCMAKE_PREFIX_PATH=~/local
# 编译
make -j4
# 运行
./my_async_app

3.核心组件

4.快速上手示例

示例 1：无栈协程（Lazy）链式调用

#include <async_simple/coro/Lazy.h>
#include <async_simple/executor/SimpleExecutor.h>
#include <async_simple/syncAwait.h>
#include <iostream>
using namespace async_simple;
using namespace async_simple::coro;

// 异步任务 1：模拟 IO 操作（延迟 1s）
Lazy<int> asyncTask1() {
  co_await sleep(1000); // 异步睡眠（不阻塞线程）
  co_return 42; // 协程返回值
}

// 异步任务 2：依赖任务 1 的结果
Lazy<std::string> asyncTask2(int val) {
  co_await sleep(500);
  co_return "Result: " + std::to_string(val * 2);
}

int main() {
  // 创建单线程执行器
  executor::SimpleExecutor ex(1);
  // 链式调用：task1 -> task2，通过 syncAwait 阻塞等待结果
  auto result = syncAwait(
    asyncTask1()
      .then([](int val) { return asyncTask2(val); }) // 链式调用
      .via(&ex) // 指定执行器
  );
  std::cout << result << std::endl; // 输出：Result: 84
  return 0;
}

示例 2：C++20 协程兼容（co_await）

#include <async_simple/coro/Cpp20Coroutine.h>
#include <async_simple/executor/ThreadPoolExecutor.h>
#include <iostream>
using namespace async_simple;
using namespace async_simple::coro;

// C++20 协程任务（需编译器开启 -std=c++20）
Task<std::string> cpp20Task(ThreadPoolExecutor& ex) {
  // co_await 异步任务
  auto val = co_await Lazy<int>([]() -> Lazy<int> {
    co_await sleep(800);
    co_return 100;
  }).via(&ex);
  co_return "Cpp20 Coro Result: " + std::to_string(val);
}

int main() {
  ThreadPoolExecutor ex(4); // 4 线程池
  auto result = syncAwait(cpp20Task(ex));
  std::cout << result << std::endl; // 输出：Cpp20 Coro Result: 100
  return 0;
}

示例 3：异步互斥锁（AsyncMutex）

#include <async_simple/coro/Lazy.h>
#include <async_simple/sync/AsyncMutex.h>
#include <async_simple/executor/ThreadPoolExecutor.h>
#include <iostream>
using namespace async_simple;
using namespace async_simple::coro;
using namespace async_simple::sync;

AsyncMutex mutex;
int shared_val = 0;

Lazy<void> increment(ThreadPoolExecutor& ex) {
  // 异步加锁（不阻塞线程）
  auto guard = co_await mutex.lock();
  shared_val++;
  std::cout << "Shared val: " << shared_val << std::endl; // 自动解锁（guard 析构）
}

int main() {
  ThreadPoolExecutor ex(4); // 并行执行 10 个任务，通过 AsyncMutex 保证线程安全
  std::vector<Lazy<void>> tasks;
  for (int i = 0; i < 10; ++i) {
    tasks.emplace_back(increment(ex));
  }
  // 等待所有任务完成
  syncAwait(whenAll(std::move(tasks)));
  return 0;
}

5.适用场景

1. IO 密集型应用：网络服务器（HTTP/RPC）、数据库客户端、文件 IO 等（无栈协程优势明显）。
2. 高并发系统：需要大量并发任务但不想用线程（线程开销高）的场景（如百万级长连接服务）。
3. 低延迟场景：协程上下文切换开销远低于线程，适合对延迟敏感的系统。
4. 现有同步代码改造：无需重写代码，通过 syncAwait/blockOn 快速接入异步模型。
5. C++11+ 项目：无法使用 C++20 协程，但需要异步能力的旧项目。

6.与其他异步库对比

核心优势：async_simple 平衡了「易用性」和「性能」，无需依赖重型库，兼容旧标准，同时提供了完整的异步生态（协程、执行器、同步原语）。

7.注意事项

1. 协程生命周期：无栈协程依赖执行器调度，需确保执行器生命周期长于协程任务。
2. 异常处理：异步任务的异常需通过 co_await 传播或 then 中捕获，避免未处理异常崩溃。
3. C++20 兼容：若使用 C++20 协程，需开启编译器选项（如 -std=c++20），并确保执行器支持 C++20 协程调度。
4. 性能优化：IO 密集型任务优先使用 Lazy（无栈协程），CPU 密集型任务优先使用 ThreadPoolExecutor。

8.总结

如果需要开发高并发、低延迟的 C++ 异步应用，且希望避免复杂依赖，async_simple 是非常优秀的选择。