一、Async++ 代码目录结构
Async++ 项目的目录结构清晰，主要包含根目录下的配置文件、源代码目录、头文件目录以及示例代码目录，具体结构如下：
asyncplusplus/
├── .gitignore # Git 忽略文件配置
├── Async++Config.cmake.in # CMake 配置模板文件
├── CMakeLists.txt # CMake 构建脚本
├── LICENSE # 许可证文件（MIT 许可证）
├── README.md # 项目说明文档
├── examples/ # 示例代码目录
│ └── gtk_scheduler.cpp # GTK 调度器示例
├── src/ # 源代码目录
│ ├── fifo_queue.h # FIFO 队列实现
│ ├── internal.h # 内部头文件（包含类型定义、宏等）
│ ├── scheduler.cpp # 调度器实现
│ ├── singleton.h # 单例模式实现
│ ├── task_wait_event.h # 任务等待事件实现
│ ├── threadpool_scheduler.cpp # 线程池调度器实现
│ └── work_steal_queue.h # 工作窃取队列实现
└── include/ # 头文件目录├── async++.h # 主头文件（对外提供统一接口）└── async++/ # 子模块头文件目录├── aligned_alloc.h├── cancel.h├── continuation_vector.h├── parallel_for.h├── parallel_invoke.h├── parallel_reduce.h├── partitioner.h # 分区器相关定义├── range.h # 范围（迭代器对）相关定义├── ref_count.h├── scheduler.h # 调度器接口定义├── scheduler_fwd.h├── task.h # 任务类定义├── task_base.h # 任务基类定义├── traits.h└── when_all_any.h二、aligned_alloc.h源码分析
2.1 源码
// Copyright (c) 2015 Amanieu d'Antras
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
namespace async {
namespace detail {
// Allocate an aligned block of memory
LIBASYNC_EXPORT void* aligned_alloc(std::size_t size, std::size_t align);
// Free an aligned block of memory
LIBASYNC_EXPORT void aligned_free(void* addr) LIBASYNC_NOEXCEPT;
// Class representing an aligned array and its length
template::value>
class aligned_array {std::size_t length;T* ptr;
public:aligned_array(): length(0), ptr(nullptr) {}aligned_array(std::nullptr_t): length(0), ptr(nullptr) {}explicit aligned_array(std::size_t length_): length(length_){ptr = static_cast(aligned_alloc(length * sizeof(T), Align));std::size_t i;LIBASYNC_TRY {for (i = 0; i < length; i++)new(ptr + i) T;} LIBASYNC_CATCH(...) {for (std::size_t j = 0; j < i; j++)ptr[i].~T();aligned_free(ptr);LIBASYNC_RETHROW();}}aligned_array(aligned_array&& other) LIBASYNC_NOEXCEPT: length(other.length), ptr(other.ptr){other.ptr = nullptr;other.length = 0;}aligned_array& operator=(aligned_array&& other) LIBASYNC_NOEXCEPT{aligned_array(std::move(*this));std::swap(ptr, other.ptr);std::swap(length, other.length);return *this;}aligned_array& operator=(std::nullptr_t){return *this = aligned_array();}~aligned_array(){for (std::size_t i = 0; i < length; i++)ptr[i].~T();aligned_free(ptr);}T& operator[](std::size_t i) const{return ptr[i];}std::size_t size() const{return length;}T* get() const{return ptr;}explicit operator bool() const{return ptr != nullptr;}
};
} // namespace detail
} // namespace async 2.2 核心功能：内存对齐工具
内存对齐在并发编程中很重要（例如避免缓存行冲突、适配特定硬件指令等），这段代码提供了基础的对齐内存管理能力。
（1）aligned_alloc 和 aligned_free
aligned_alloc：分配一块指定大小（size）和对齐要求（align）的内存块，返回 void 指针。LIBASYNC_EXPORT宏表明该函数是导出的（供框架内部其他模块使用）。aligned_free：释放由aligned_alloc分配的内存块，LIBASYNC_NOEXCEPT表明该函数不会抛出异常。
这两个函数是底层内存管理接口，封装了平台相关的对齐内存分配逻辑（例如可能基于 posix_memalign 或 Windows 的 _aligned_malloc 实现）。
（2）模板类 aligned_array
一个封装了 “对齐数组” 的 RAII 类，用于管理指定类型 T 的数组，且数组内存满足指定对齐要求（默认是 T 类型的自然对齐值 std::alignment_of<T>::value）。
核心成员
length：数组元素数量。ptr：指向对齐内存的T*指针。
关键方法解析
构造函数：
- 默认构造函数：初始化空数组（
length=0，ptr=nullptr）。 - 带长度的构造函数：通过
aligned_alloc分配内存，并在分配的内存上逐个调用T的构造函数（placement new）。若构造过程中抛出异常，会自动销毁已构造的元素并释放内存（异常安全）。 - 移动构造函数：转移数组所有权（避免深拷贝，提高效率）。
- 默认构造函数：初始化空数组（
赋值运算符：
- 移动赋值：通过交换指针和长度实现资源转移，旧资源会被临时对象的析构函数自动释放。
- 赋值
nullptr：重置为为空数组。
析构函数：
- 逐个调用数组元素的析构函数（
~T()），然后通过aligned_free释放底层内存，确保资源不泄漏。
- 逐个调用数组元素的析构函数（
其他接口：
operator[]：访问数组元素（类似普通数组）。size()：返回元素数量。get()：返回底层指针。- 显式转换为
bool：判断数组是否非空。
2.3 设计亮点
- 异常安全：在构造数组时，若元素构造抛出异常，会自动回滚（销毁已构造元素 + 释放内存），符合 RAII 设计原则。
- 移动语义：通过移动构造和移动赋值，避免了大数组的深拷贝，提升性能。
- 模板灵活性：可指定元素类型
T和对齐要求Align，适应不同场景（例如需要 64 字节对齐以匹配缓存行的场景）。
2.4. 用途
该类主要用于框架内部需要对齐内存的场景，例如：
- 管理并发数据结构（如工作窃取队列）的内部数组，避免因内存未对齐导致的性能损耗。
- 存储需要特定对齐的类型（如 SIMD 指令相关的数据）。
通过封装对齐内存的分配、构造、析构和释放逻辑，简化了安全管理对齐数组的代码，减少了内存泄漏或异常安全问题的风险。
三、核心用法示例
3.1. 包含头文件
需包含定义该类的头文件（通常是框架内部的 aligned_alloc.h）：
#include "async++.h"3.2. 创建对齐数组
// 创建一个包含 10 个 int 元素的数组，默认对齐（int 的自然对齐，通常 4 字节）
async::detail::aligned_array arr1(10);
// 创建一个包含 5 个 double 元素的数组，强制 64 字节对齐（适合缓存行优化）
async::detail::aligned_array arr2(5); - 构造时会自动分配对齐内存，并为每个元素调用默认构造函数（
T()）。 - 若
T没有默认构造函数，需确保构造时能正确初始化（例如T有其他构造函数时，可能需要配合额外逻辑）。
3.3. 访问数组元素
通过 operator[] 或 get() 指针访问：
// 访问 arr1 的第 3 个元素（索引从 0 开始）
arr1[2] = 42;
std::cout << arr1[2] << std::endl; // 输出 42
// 通过 get() 获取底层指针，进行迭代
double* ptr = arr2.get();
for (size_t i = 0; i < arr2.size(); ++i) {ptr[i] = i * 1.5;
}3.4. 移动语义（避免拷贝开销）
aligned_array 禁用了拷贝构造和拷贝赋值（未显式定义，且移动操作会转移资源），仅支持移动，适合高效传递数组所有权：
// 移动构造：arr3 接管 arr1 的资源，arr1 变为空
async::detail::aligned_array arr3(std::move(arr1));
// 移动赋值：arr4 接管 arr3 的资源，arr3 变为空
async::detail::aligned_array arr4;
arr4 = std::move(arr3); 3.5. 重置数组（释放资源）
通过赋值 nullptr 或析构函数自动释放资源：
// 手动重置：释放内存，元素析构
arr4 = nullptr;
// 超出作用域时，析构函数自动调用，释放资源
{async::detail::aligned_array temp(5);
} // temp 析构，内存释放 3.6. 检查数组是否有效
通过显式 bool 转换判断数组是否非空：
if (arr2) { // 等价于 arr2.get() != nullptrstd::cout << "arr2 包含 " << arr2.size() << " 个元素" << std::endl;
}四、适用场景
由于 aligned_array 保证了内存对齐，主要用于：
- 高性能并发数据结构：例如工作窃取队列（
work_steal_queue），避免因内存未对齐导致的 CPU 缓存冲突。 - 底层内存管理：需要严格对齐的场景（如 SIMD 指令、硬件特定要求等）。
- 异常安全的数组管理：自动处理构造 / 析构过程中的异常，避免资源泄漏。
