docs: update memory and threading API docs

docs/api/memory/pool-allocator/constructor.md

@@ -0,0 +1,40 @@
+# PoolAllocator::PoolAllocator
+
+```cpp
+PoolAllocator(size_t blockSize, size_t poolSize, size_t alignment = 8);
+```
+
+构造内存池分配器，预分配 `poolSize` 个大小为 `blockSize` 字节的内存块。内存块按 `alignment` 对齐（默认 8 字节）。内部维护一个空闲链表来管理分配。
+
+**参数：**
+- `blockSize` - 每个内存块的大小（字节）
+- `poolSize` - 内存池中总块数
+- `alignment` - 对齐要求，默认为 8 字节
+
+**返回：** 无
+
+**复杂度：** O(n)，需要预分配所有块
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+struct Particle {
+    float x, y, z;
+    float vx, vy, vz;
+    float life;
+};
+
+// 创建一个能容纳 1000 个 Particle 的内存池，16 字节对齐
+PoolAllocator pool(sizeof(Particle), 1000, alignof(Particle));
+
+size_t blockSize = pool.GetBlockSize();   // sizeof(Particle)
+size_t total = pool.GetTotalBlockCount(); // 1000
+size_t free = pool.GetFreeBlockCount();   // 1000
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览
+- [`~PoolAllocator`](~pool-allocator.md) - 析构函数

docs/api/memory/pool-allocator/get-allocation-count.md

@@ -0,0 +1,40 @@
+# PoolAllocator::GetAllocationCount
+
+```cpp
+size_t GetAllocationCount() const override;
+```
+
+返回当前已分配块的数量。计算公式：`m_totalBlocks - m_freeBlocks`。
+
+**参数：** 无
+
+**返回：** 当前已分配块的数量
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+size_t count = pool.GetAllocationCount(); // 0
+
+void* blocks[10];
+for (int i = 0; i < 10; ++i) {
+    blocks[i] = pool.Allocate();
+}
+
+count = pool.GetAllocationCount(); // 10
+
+for (int i = 0; i < 5; ++i) {
+    pool.Free(blocks[i]);
+}
+
+count = pool.GetAllocationCount(); // 5
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-block-size.md

@@ -4,7 +4,7 @@
 size_t GetBlockSize() const;
 ```
 
-返回内存池中每个内存块的大小。此值在构造时确定，之后保持不变。
+返回内存池中每个内存块的大小。此值在构造时确定，之后保持不变。实际分配的内存可能按对齐要求调整，但块大小返回原始请求值。
 
 **参数：** 无
 

docs/api/memory/pool-allocator/get-name.md

@@ -0,0 +1,29 @@
+# PoolAllocator::GetName
+
+```cpp
+const char* GetName() const override;
+```
+
+返回分配器的名称字符串 "PoolAllocator"。用于调试和日志记录。
+
+**参数：** 无
+
+**返回：** 固定返回 `"PoolAllocator"` 字符串
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+#include <iostream>
+
+PoolAllocator pool(sizeof(int), 100);
+
+const char* name = pool.GetName(); // "PoolAllocator"
+std::cout << "Allocator: " << name << std::endl;
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-peak-allocated.md

@@ -0,0 +1,33 @@
+# PoolAllocator::GetPeakAllocated
+
+```cpp
+size_t GetPeakAllocated() const override;
+```
+
+返回峰值分配的内存总量（字节）。由于池在构造时预分配所有块，峰值即为 `m_totalBlocks * m_blockSize`。
+
+**参数：** 无
+
+**返回：** 内存池总容量（字节）
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+size_t peak = pool.GetPeakAllocated(); // 100 * sizeof(int)
+
+// 即使分配了部分块，峰值仍然是总容量
+void* block1 = pool.Allocate();
+void* block2 = pool.Allocate();
+size_t current = pool.GetTotalAllocated(); // 2 * sizeof(int)
+peak = pool.GetPeakAllocated();            // 100 * sizeof(int)
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-total-allocated.md

@@ -0,0 +1,33 @@
+# PoolAllocator::GetTotalAllocated
+
+```cpp
+size_t GetTotalAllocated() const override;
+```
+
+返回当前已分配的内存总量（字节）。计算公式：`(m_totalBlocks - m_freeBlocks) * m_blockSize`。
+
+**参数：** 无
+
+**返回：** 当前已分配块的字节数
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+size_t allocated = pool.GetTotalAllocated(); // 0
+
+void* block = pool.Allocate();
+allocated = pool.GetTotalAllocated(); // sizeof(int)
+
+pool.Free(block);
+allocated = pool.GetTotalAllocated(); // 0
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/get-total-freed.md

@@ -0,0 +1,33 @@
+# PoolAllocator::GetTotalFreed
+
+```cpp
+size_t GetTotalFreed() const override;
+```
+
+返回当前空闲的内存总量（字节）。计算公式：`m_freeBlocks * m_blockSize`。
+
+**参数：** 无
+
+**返回：** 当前空闲块的字节数
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+#include <XCEngine/Memory/PoolAllocator.h>
+
+PoolAllocator pool(sizeof(int), 100);
+
+size_t freed = pool.GetTotalFreed(); // 100 * sizeof(int)
+
+void* block = pool.Allocate();
+freed = pool.GetTotalFreed(); // 99 * sizeof(int)
+
+pool.Free(block);
+freed = pool.GetTotalFreed(); // 100 * sizeof(int)
+```
+
+## 相关文档
+
+- [PoolAllocator 总览](pool-allocator.md) - 返回类总览

docs/api/memory/pool-allocator/pool-allocator.md

@@ -4,6 +4,8 @@
 
 **类型**: `class`
 
+**头文件**: `XCEngine/Memory/PoolAllocator.h`
+
 **描述**: 内存池分配器，预分配固定大小的内存块池。
 
 ## 概述
@@ -14,15 +16,20 @@
 
 | 方法 | 描述 |
 |------|------|
-| `PoolAllocator` | 构造内存池分配器 |
-| `~PoolAllocator` | 析构函数，释放整个内存池 |
-| `Allocate` | 分配一个内存块 |
-| `Free` | 释放内存块回空闲链表 |
-| `Reallocate` | 不支持（始终返回 nullptr） |
-| `Contains` | 检查指针是否属于此池 |
-| `GetBlockSize` | 获取块大小 |
-| `GetFreeBlockCount` | 获取空闲块数量 |
-| `GetTotalBlockCount` | 获取总块数 |
+| [`PoolAllocator`](constructor.md) | 构造内存池分配器 |
+| [`~PoolAllocator`](~pool-allocator.md) | 析构函数，释放整个内存池 |
+| [`Allocate`](allocate.md) | 分配一个内存块 |
+| [`Free`](free.md) | 释放内存块回空闲链表 |
+| [`Reallocate`](reallocate.md) | 不支持（始终返回 nullptr） |
+| [`Contains`](contains.md) | 检查指针是否属于此池 |
+| [`GetBlockSize`](get-block-size.md) | 获取块大小 |
+| [`GetFreeBlockCount`](get-free-block-count.md) | 获取空闲块数量 |
+| [`GetTotalBlockCount`](get-total-block-count.md) | 获取总块数 |
+| [`GetName`](get-name.md) | 获取分配器名称 |
+| [`GetTotalAllocated`](get-total-allocated.md) | 获取当前已分配内存 |
+| [`GetTotalFreed`](get-total-freed.md) | 获取当前空闲内存 |
+| [`GetPeakAllocated`](get-peak-allocated.md) | 获取峰值分配内存 |
+| [`GetAllocationCount`](get-allocation-count.md) | 获取当前分配块数量 |
 
 ## 构造函数