fix: improve doc link navigation and tree display

- Fix link resolution with proper relative/absolute path handling
- Improve link styling with underline decoration
- Hide leaf nodes from tree, only show directories
- Fix log file path for packaged app

docs/api/threading/lambdatask/constructor.md

@@ -0,0 +1,41 @@
+# LambdaTask::LambdaTask
+
+```cpp
+explicit LambdaTask(Func&& func, TaskPriority priority = TaskPriority::Normal)
+```
+
+构造 Lambda 任务对象，将可调用对象包装为 ITask。
+
+**模板参数：**
+- `Func` - 可调用对象类型
+
+**参数：**
+- `func` - 要封装的可调用对象（lambda、函数指针、std::function 等）
+- `priority` - 任务优先级，默认值为 TaskPriority::Normal
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+// 使用 std::function lambda
+auto task = std::make_unique<LambdaTask<std::function<void()>>>(
+    []() { printf("Task executed\n"); },
+    TaskPriority::High
+);
+TaskSystem::Get().Submit(std::move(task));
+
+// 配合 TaskSystem::Submit 的重载直接使用
+TaskSystem::Get().Submit(
+    std::make_unique<LambdaTask<std::function<void()>>>(
+        []() { ProcessData(); },
+        TaskPriority::Critical
+    )
+);
+```
+
+## 相关文档
+
+- [LambdaTask 总览](lambdatask.md) - 返回类总览

docs/api/threading/lambdatask/lambdatask.md

@@ -0,0 +1,57 @@
+# LambdaTask
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class` (template)
+
+**头文件**: `XCEngine/Threading/LambdaTask.h`
+
+**描述**: Lambda 任务封装模板类，允许使用 lambda 表达式创建任务，无需继承 ITask。
+
+## 概述
+
+`LambdaTask<Func>` 是一个模板封装类，将任意可调用对象（lambda、函数指针、std::function）包装为 `ITask`。这大大简化了简短任务的创建。
+
+## 模板参数
+
+| 参数 | 描述 |
+|------|------|
+| `Func` | 可调用对象类型 |
+
+## 构造方法
+
+| 方法 | 描述 |
+|------|------|
+| [`LambdaTask`](constructor.md) | 构造 Lambda 任务 |
+
+## 继承方法
+
+| 方法 | 描述 |
+|------|------|
+| `Execute()` | 执行封装的可调用对象（继承自 ITask，可重写） |
+
+## 使用示例
+
+```cpp
+// 使用 lambda 创建任务
+TaskSystem::Get().Submit(
+    std::make_unique<LambdaTask<std::function<void()>>>(
+        []() {
+            printf("Hello from task!\n");
+        },
+        TaskPriority::Normal
+    )
+);
+
+// 或者直接使用 Submit 的便捷重载
+TaskSystem::Get().Submit([]() {
+    printf("Direct lambda task!\n");
+});
+```
+
+## 相关文档
+
+- [ITask](../task/task.md) - 任务基类
+- [TaskGroup](../task-group/task-group.md) - 任务组
+- [TaskSystem](../task-system/task-system.md) - 任务系统
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/mutex/lock.md

@@ -0,0 +1,34 @@
+# Mutex::Lock
+
+```cpp
+void Lock()
+```
+
+获取互斥锁。如果锁已被其他线程持有，则阻塞当前线程直到锁可用。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 平均 O(1)，最坏情况 O(n)，n 为竞争线程数
+
+**注意：**
+- 同一线程不可重复 Lock 同一个 Mutex（会导致死锁）。
+- 建议使用 RAII 封装（如 std::lock_guard）自动管理锁的释放。
+
+**示例：**
+
+```cpp
+Threading::Mutex mtx;
+int counter = 0;
+
+void Increment() {
+    mtx.Lock();
+    ++counter;
+    mtx.Unlock();
+}
+```
+
+## 相关文档
+
+- [Mutex 总览](mutex.md) - 返回类总览

docs/api/threading/mutex/mutex.md

@@ -0,0 +1,54 @@
+# Mutex
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class`
+
+**头文件**: `XCEngine/Threading/Mutex.h`
+
+**描述**: 互斥锁封装类，基于 `std::mutex` 实现，提供线程安全的互斥访问。
+
+## 概述
+
+`Mutex` 是对 `std::mutex` 的简单封装，提供了标准的 Lock/Unlock/TryLock 接口。它是 XCEngine 中最基础的同步原语，适用于保护共享数据的访问。
+
+## 公共方法
+
+| 方法 | 描述 |
+|------|------|
+| [`Lock`](lock.md) | 获取锁（阻塞） |
+| [`Unlock`](unlock.md) | 释放锁 |
+| [`TryLock`](trylock.md) | 尝试获取锁（非阻塞，成功返回 true） |
+
+## STL 兼容方法
+
+支持 `lock()`, `unlock()`, `try_lock()` 以兼容 STL 的 lockable 概念。**注意**：这些方法为 `const` 成员函数。
+
+## 使用示例
+
+```cpp
+Threading::Mutex mtx;
+int sharedData = 0;
+
+// 线程安全地修改共享数据
+void SafeIncrement() {
+    mtx.Lock();
+    ++sharedData;
+    mtx.Unlock();
+}
+
+// 或使用 TryLock
+void SafeTryIncrement() {
+    if (mtx.TryLock()) {
+        ++sharedData;
+        mtx.Unlock();
+    }
+}
+```
+
+## 相关文档
+
+- [SpinLock](../spinlock/spinlock.md) - 自旋锁
+- [ReadWriteLock](../readwritelock/readwritelock.md) - 读写锁
+- [TaskSystem](../task-system/task-system.md) - 任务系统
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/mutex/trylock.md

@@ -0,0 +1,36 @@
+# Mutex::TryLock
+
+```cpp
+bool TryLock()
+```
+
+尝试获取互斥锁（非阻塞）。如果锁可用则立即获取并返回 true，否则立即返回 false 而不阻塞。
+
+**参数：** 无
+
+**返回：** `bool` - 获取成功返回 true，锁不可用返回 false
+
+**复杂度：** O(1)
+
+**使用场景：** 适用于需要尝试获取锁但不希望阻塞的场景，如实现无锁算法或避免死锁。
+
+**示例：**
+
+```cpp
+Threading::Mutex mtx;
+volatile bool updated = false;
+
+void TryUpdate() {
+    if (mtx.TryLock()) {
+        updated = true;
+        mtx.Unlock();
+        printf("Update succeeded\n");
+    } else {
+        printf("Update skipped (lock held)\n");
+    }
+}
+```
+
+## 相关文档
+
+- [Mutex 总览](mutex.md) - 返回类总览

docs/api/threading/mutex/unlock.md

@@ -0,0 +1,32 @@
+# Mutex::Unlock
+
+```cpp
+void Unlock()
+```
+
+释放互斥锁，允许其他等待中的线程获取该锁。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：** 必须在持有锁的线程中调用 Unlock。解锁一个未持有的锁将导致未定义行为。
+
+**示例：**
+
+```cpp
+Threading::Mutex mtx;
+std::vector<int> data;
+
+void SafePush(int value) {
+    mtx.Lock();
+    data.push_back(value);
+    mtx.Unlock();
+}
+```
+
+## 相关文档
+
+- [Mutex 总览](mutex.md) - 返回类总览

docs/api/threading/readwritelock/readlock.md

@@ -0,0 +1,36 @@
+# ReadWriteLock::ReadLock
+
+```cpp
+void ReadLock()
+```
+
+获取读锁。如果有写者持有锁或正在等待写锁，当前线程将阻塞，直到所有写者完成。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 平均 O(1)
+
+**注意：**
+- 多个读者可以同时持有读锁。
+- 写锁具有优先权——正在等待的写者会阻塞新的读者，防止写者饥饿。
+- 读锁不可重入，同一线程不可嵌套持有读锁（会导致死锁）。
+
+**示例：**
+
+```cpp
+ReadWriteLock rwLock;
+int sharedValue = 0;
+
+int ReadValue() {
+    rwLock.ReadLock();
+    int value = sharedValue;
+    rwLock.ReadUnlock();
+    return value;
+}
+```
+
+## 相关文档
+
+- [ReadWriteLock 总览](readwritelock.md) - 返回类总览

docs/api/threading/readwritelock/readunlock.md

@@ -0,0 +1,33 @@
+# ReadWriteLock::ReadUnlock
+
+```cpp
+void ReadUnlock()
+```
+
+释放读锁。如果这是最后一个读者，将唤醒等待中的写者。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：** 必须与 ReadLock 配对使用，且在持有读锁的线程中调用。
+
+**示例：**
+
+```cpp
+ReadWriteLock rwLock;
+float sharedData = 0.0f;
+
+float GetData() {
+    rwLock.ReadLock();
+    float data = sharedData;
+    rwLock.ReadUnlock();
+    return data;
+}
+```
+
+## 相关文档
+
+- [ReadWriteLock 总览](readwritelock.md) - 返回类总览

docs/api/threading/readwritelock/readwritelock.md

@@ -0,0 +1,57 @@
+# ReadWriteLock
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class`
+
+**头文件**: `XCEngine/Threading/ReadWriteLock.h`
+
+**描述**: 读写锁实现，支持多个并发读取或单一写入，提高读多写少场景的并发性能。
+
+## 概述
+
+`ReadWriteLock` 实现了一个经典的读写锁。它允许多个线程同时持有读锁，但在有写锁时，所有读锁都必须释放，写锁为独占访问。这对于读操作远多于写操作的共享数据非常有效。
+
+## 公共方法
+
+### 读锁
+
+| 方法 | 描述 |
+|------|------|
+| [`ReadLock`](readlock.md) | 获取读锁（可重入，支持多个并发读者） |
+| [`ReadUnlock`](readunlock.md) | 释放读锁 |
+
+### 写锁
+
+| 方法 | 描述 |
+|------|------|
+| [`WriteLock`](writelock.md) | 获取写锁（独占，阻塞所有读者和写者） |
+| [`WriteUnlock`](writeunlock.md) | 释放写锁 |
+
+## 使用示例
+
+```cpp
+Threading::ReadWriteLock rwLock;
+Containers::HashMap<String, int> sharedMap;
+
+// 读操作（多个线程可同时读）
+int* ReadData(const String& key) {
+    rwLock.ReadLock();
+    int* value = sharedMap.Find(key);
+    rwLock.ReadUnlock();
+    return value;
+}
+
+// 写操作（独占）
+void WriteData(const String& key, int value) {
+    rwLock.WriteLock();
+    sharedMap.Insert(key, value);
+    rwLock.WriteUnlock();
+}
+```
+
+## 相关文档
+
+- [Mutex](../mutex/mutex.md) - 互斥锁
+- [SpinLock](../spinlock/spinlock.md) - 自旋锁
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/readwritelock/writelock.md

@@ -0,0 +1,35 @@
+# ReadWriteLock::WriteLock
+
+```cpp
+void WriteLock()
+```
+
+获取写锁（独占）。如果有读者持有锁或有其他写者正在等待，当前线程将阻塞，直到获得独占访问权。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 平均 O(1)，写者饥饿时可能 O(n)
+
+**注意：**
+- 写锁为独占访问，持有期间不允许任何读锁或写锁。
+- 写锁具有优先权，会阻塞后续到达的读者。
+- 同一线程不可重复 WriteLock。
+
+**示例：**
+
+```cpp
+ReadWriteLock rwLock;
+std::vector<int> buffer;
+
+void Append(int value) {
+    rwLock.WriteLock();
+    buffer.push_back(value);
+    rwLock.WriteUnlock();
+}
+```
+
+## 相关文档
+
+- [ReadWriteLock 总览](readwritelock.md) - 返回类总览

docs/api/threading/readwritelock/writeunlock.md

@@ -0,0 +1,32 @@
+# ReadWriteLock::WriteUnlock
+
+```cpp
+void WriteUnlock()
+```
+
+释放写锁。唤醒所有等待中的读者和下一个写者。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：** 必须在持有写锁的线程中调用。
+
+**示例：**
+
+```cpp
+ReadWriteLock rwLock;
+std::unordered_map<String, int> cache;
+
+void UpdateCache(const String& key, int value) {
+    rwLock.WriteLock();
+    cache[key] = value;
+    rwLock.WriteUnlock();
+}
+```
+
+## 相关文档
+
+- [ReadWriteLock 总览](readwritelock.md) - 返回类总览

docs/api/threading/spinlock/lock.md

@@ -0,0 +1,35 @@
+# SpinLock::Lock
+
+```cpp
+void Lock()
+```
+
+获取自旋锁。如果锁已被其他线程持有，则使用忙等待（spin）持续轮询，直到获取到锁。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 平均 O(1)，最坏情况取决于竞争程度
+
+**注意：**
+- 适用于临界区极短（几个 CPU 指令）的场景，避免线程切换开销。
+- 在锁持有时间较长或多核竞争激烈时，会浪费大量 CPU 周期，此时应使用 Mutex。
+- 同一线程不可重复 Lock 同一个 SpinLock。
+
+**示例：**
+
+```cpp
+Threading::SpinLock spinLock;
+int64_t fastCounter = 0;
+
+void IncrementFast() {
+    spinLock.Lock();
+    ++fastCounter;
+    spinLock.Unlock();
+}
+```
+
+## 相关文档
+
+- [SpinLock 总览](spinlock.md) - 返回类总览

docs/api/threading/spinlock/spinlock.md

@@ -0,0 +1,53 @@
+# SpinLock
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class`
+
+**头文件**: `XCEngine/Threading/SpinLock.h`
+
+**描述**: 自旋锁封装类，使用原子操作实现，适用于保护极短的临界区。
+
+## 概述
+
+`SpinLock` 是一个轻量级的自旋锁实现，使用 `std::atomic_flag` 的 test-and-set 操作。它在获取锁失败时不断轮询，不会导致线程切换，非常适合保护非常短的临界区（如简单的计数器递增）。
+
+## 公共方法
+
+| 方法 | 描述 |
+|------|------|
+| [`Lock`](lock.md) | 获取锁（忙等待） |
+| [`Unlock`](unlock.md) | 释放锁 |
+| [`TryLock`](trylock.md) | 尝试获取锁（非阻塞） |
+
+## STL 兼容方法
+
+支持 `lock()`, `unlock()`, `try_lock()` 以兼容 STL 的 lockable 概念。**注意**：这些方法为非 `const` 成员函数。
+
+## 使用示例
+
+```cpp
+Threading::SpinLock spinLock;
+int counter = 0;
+
+// 保护极短的临界区
+void FastIncrement() {
+    spinLock.Lock();
+    ++counter;
+    spinLock.Unlock();
+}
+
+// TryLock 用法
+void SafeIncrement() {
+    if (spinLock.TryLock()) {
+        ++counter;
+        spinLock.Unlock();
+    }
+}
+```
+
+## 相关文档
+
+- [Mutex](../mutex/mutex.md) - 互斥锁
+- [ReadWriteLock](../readwritelock/readwritelock.md) - 读写锁
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/spinlock/trylock.md

@@ -0,0 +1,31 @@
+# SpinLock::TryLock
+
+```cpp
+bool TryLock()
+```
+
+尝试获取自旋锁（非阻塞）。如果锁可用则立即获取并返回 true，否则立即返回 false。
+
+**参数：** 无
+
+**返回：** `bool` - 获取成功返回 true，锁不可用返回 false
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+Threading::SpinLock spinLock;
+int64_t counter = 0;
+
+void TryIncrement() {
+    if (spinLock.TryLock()) {
+        ++counter;
+        spinLock.Unlock();
+    }
+}
+```
+
+## 相关文档
+
+- [SpinLock 总览](spinlock.md) - 返回类总览

docs/api/threading/spinlock/unlock.md

@@ -0,0 +1,32 @@
+# SpinLock::Unlock
+
+```cpp
+void Unlock()
+```
+
+释放自旋锁，允许其他等待中的线程获取该锁。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：** 必须在持有锁的线程中调用 Unlock。
+
+**示例：**
+
+```cpp
+Threading::SpinLock spinLock;
+int64_t counter = 0;
+
+void SafeAdd(int64_t value) {
+    spinLock.Lock();
+    counter += value;
+    spinLock.Unlock();
+}
+```
+
+## 相关文档
+
+- [SpinLock 总览](spinlock.md) - 返回类总览

docs/api/threading/task-group/adddependency.md

@@ -0,0 +1,44 @@
+# TaskGroup::AddDependency
+
+```cpp
+void AddDependency(uint64_t taskId, uint64_t dependsOn)
+```
+
+为任务添加依赖关系。被依赖的任务必须先完成，当前任务才会开始执行。
+
+**参数：**
+- `taskId` - 任务 ID（需要等待的任务）
+- `dependsOn` - 依赖的父任务 ID
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：**
+- 如果被依赖的任务不存在或已完成，调用无效果。
+- 支持添加多个依赖，但不支持循环依赖。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+uint64_t init = group->AddTask([]() { Initialize(); });
+uint64_t task1 = group->AddTask([]() { Phase1(); });
+uint64_t task2 = group->AddTask([]() { Phase2(); });
+uint64_t cleanup = group->AddTask([]() { Cleanup(); });
+
+// task1 和 task2 依赖 init
+group->AddDependency(task1, init);
+group->AddDependency(task2, init);
+
+// cleanup 依赖 task1 和 task2
+group->AddDependency(cleanup, task1);
+group->AddDependency(cleanup, task2);
+
+group->Wait();
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览

docs/api/threading/task-group/addtask.md

@@ -0,0 +1,60 @@
+# TaskGroup::AddTask
+
+添加任务到任务组。有两个重载版本。
+
+## 重载 1: 添加 ITask 对象
+
+```cpp
+uint64_t AddTask(std::unique_ptr<ITask> task)
+```
+
+将一个已有的 ITask 对象添加到任务组。
+
+**参数：**
+- `task` - 要添加的 unique_ptr 任务对象
+
+**返回：** `uint64_t` - 分配的任务 ID
+
+**复杂度：** O(1)
+
+## 重载 2: 添加 lambda 任务
+
+```cpp
+uint64_t AddTask(Callback&& func, TaskPriority priority = TaskPriority::Normal)
+```
+
+将一个 lambda 函数包装为任务添加到任务组。
+
+**参数：**
+- `func` - 要执行的可调用对象
+- `priority` - 任务优先级，默认 TaskPriority::Normal
+
+**返回：** `uint64_t` - 分配的任务 ID
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+// 添加 lambda 任务
+uint64_t id1 = group->AddTask([]() {
+    printf("Task A running\n");
+});
+
+uint64_t id2 = group->AddTask([]() {
+    printf("Task B running\n");
+}, TaskPriority::High);
+
+// 添加自定义 ITask
+class MyTask : public ITask {
+public:
+    void Execute() override { printf("Custom task\n"); }
+};
+uint64_t id3 = group->AddTask(std::make_unique<MyTask>());
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览

docs/api/threading/task-group/cancel.md

@@ -0,0 +1,45 @@
+# TaskGroup::Cancel
+
+```cpp
+void Cancel()
+```
+
+**注意：** 此方法为**部分实现**，存在已知问题。
+
+取消任务组中所有尚未执行的任务。正在执行的任务将不受影响。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(n)
+
+**当前状态：** 此方法会调用各任务的 `OnCancel()` 回调，但不会减少 `m_pendingCount` 计数器。因此调用 `Wait()` 会导致永久阻塞。建议在 `Cancel()` 后使用 `IsComplete()` 轮询或使用带超时的 `WaitFor()`。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+for (int i = 0; i < 100; ++i) {
+    group->AddTask([i]() {
+        if (ShouldCancel()) {
+            return; // 检查取消状态
+        }
+        ProcessLongTask(i);
+    });
+}
+
+// 如果用户点击取消按钮
+if (userClickedCancel) {
+    group->Cancel();
+    printf("Tasks canceled. Progress: %.1f%%\n", group->GetProgress() * 100.0f);
+}
+
+// 注意：Cancel() 后 Wait() 会永久阻塞，应使用 WaitFor()
+group->WaitFor(std::chrono::seconds(1));
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览

docs/api/threading/task-group/getprogress.md

@@ -0,0 +1,40 @@
+# TaskGroup::GetProgress
+
+```cpp
+float GetProgress() const
+```
+
+**注意：** 此方法当前为**空实现/桩代码**。
+
+获取任务组的完成进度。
+
+**参数：** 无
+
+**返回：** `float` - 始终返回 `0.0f`（任务组为空时返回 `1.0f`）
+
+**复杂度：** O(1)
+
+**当前状态：** 此方法为空实现，始终返回 `0.0f`，因为 `m_completedCount` 未被更新。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+for (int i = 0; i < 1000; ++i) {
+    group->AddTask([i]() { ProcessItem(i); });
+}
+
+// 显示进度（注意：当前实现始终返回 0.0f）
+while (!group->IsComplete()) {
+    float progress = group->GetProgress();
+    printf("\rProgress: %.1f%%", progress * 100.0f);
+    Thread::Sleep(100);
+}
+printf("\n");
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览
+- [IsComplete](iscomplete.md) - 检查是否完成

docs/api/threading/task-group/iscomplete.md

@@ -0,0 +1,38 @@
+# TaskGroup::IsComplete
+
+```cpp
+bool IsComplete() const
+```
+
+**注意：** 此方法当前为**空实现/桩代码**。
+
+检查任务组中所有任务是否已完成。
+
+**参数：** 无
+
+**返回：** `bool` - 始终返回 `false`（空实现）
+
+**复杂度：** O(1)（空实现）
+
+**当前状态：** 此方法为空实现，始终返回 `false`，因为 `m_pendingCount` 计数器未正确递减。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+for (int i = 0; i < 100; ++i) {
+    group->AddTask([i]() { HeavyCompute(i); });
+}
+
+// 非阻塞轮询
+while (!group->IsComplete()) {
+    printf("Progress: %.1f%%\n", group->GetProgress() * 100.0f);
+    Thread::Sleep(500);
+}
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览
+- [GetProgress](getprogress.md) - 获取完成进度

docs/api/threading/task-group/setcompletecallback.md

@@ -0,0 +1,36 @@
+# TaskGroup::SetCompleteCallback
+
+```cpp
+void SetCompleteCallback(Callback&& callback)
+```
+
+设置任务组完成回调。当所有任务都完成后，回调函数将在某个工作线程中被调用。
+
+**参数：**
+- `callback` - 完成时要调用的回调函数
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+group->AddTask([]() { LoadTextures(); });
+group->AddTask([]() { LoadMeshes(); });
+group->AddTask([]() { LoadAudio(); });
+
+group->SetCompleteCallback([]() {
+    printf("All assets loaded!\n");
+    ResourceManager::InitGPUResources();
+});
+
+group->Wait();
+TaskSystem::Get().DestroyTaskGroup(group);
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览

docs/api/threading/task-group/task-group.md

@@ -0,0 +1,66 @@
+# TaskGroup
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class`
+
+**头文件**: `XCEngine/Threading/TaskGroup.h`
+
+**描述**: 任务组管理类，用于组织多个任务并支持批量等待、进度跟踪和依赖管理。
+
+## 概述
+
+`TaskGroup` 提供了一种批量管理任务的机制。它允许添加多个任务、设置任务依赖关系、等待所有任务完成，并提供进度回调功能。
+
+## 公共类型
+
+| 类型 | 描述 |
+|------|------|
+| `Callback = std::function<void()>` | 任务组回调函数类型 |
+
+## 公共方法
+
+| 方法 | 描述 |
+|------|------|
+| `TaskGroup()` | 默认构造函数 |
+| `~TaskGroup()` | 析构函数 |
+| [`AddTask(unique_ptr)`](addtask.md) | 添加任务对象 |
+| [`AddTask(callback)`](addtask.md) | 添加 lambda 任务 |
+| [`AddDependency`](adddependency.md) | 添加任务依赖关系 |
+| [`Wait`](wait.md) | 阻塞等待所有任务完成 |
+| [`WaitFor`](waitfor.md) | 超时等待 |
+| [`SetCompleteCallback`](setcompletecallback.md) | 设置完成回调 |
+| [`IsComplete`](iscomplete.md) | 检查所有任务是否完成 |
+| [`GetProgress`](getprogress.md) | 获取完成进度（0.0f ~ 1.0f） |
+| [`Cancel`](cancel.md) | 取消所有任务 |
+
+## 使用示例
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+// 添加多个任务
+uint64_t task1 = group->AddTask([]() { /* 任务1 */ });
+uint64_t task2 = group->AddTask([]() { /* 任务2 */ });
+
+// 设置依赖：task3 等待 task1 完成
+uint64_t task3 = group->AddTask([]() { /* 任务3 */ });
+group->AddDependency(task3, task1);
+
+// 设置完成回调
+group->SetCompleteCallback([]() {
+    printf("All tasks completed!\n");
+});
+
+// 等待完成
+group->Wait();
+
+// 销毁
+TaskSystem::Get().DestroyTaskGroup(group);
+```
+
+## 相关文档
+
+- [ITask](../task/task.md) - 任务基类
+- [TaskSystem](../task-system/task-system.md) - 任务系统
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/task-group/wait.md

@@ -0,0 +1,46 @@
+# TaskGroup::Wait
+
+```cpp
+void Wait()
+```
+
+**注意：** 此方法当前为**空实现/桩代码**，不执行任何操作。
+
+阻塞当前线程，等待任务组中所有任务完成。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** N/A（空实现）
+
+**当前状态：** 此方法为空实现，不执行任何操作。由于 `m_pendingCount` 计数器未正确更新，此方法永远无法正常运作。
+
+**建议：** 使用 `WaitFor()` 代替以避免永久阻塞。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+for (int i = 0; i < 10; ++i) {
+    group->AddTask([i]() {
+        printf("Task %d running\n", i);
+    });
+}
+
+printf("Waiting for all tasks...\n");
+// 注意：Wait() 为空实现，建议使用 WaitFor()
+if (group->WaitFor(std::chrono::seconds(5))) {
+    printf("All tasks completed within 5 seconds\n");
+} else {
+    printf("Timeout! Tasks may not have completed\n");
+}
+
+TaskSystem::Get().DestroyTaskGroup(group);
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览
+- [WaitFor](waitfor.md) - 超时等待

docs/api/threading/task-group/waitfor.md

@@ -0,0 +1,39 @@
+# TaskGroup::WaitFor
+
+```cpp
+bool WaitFor(std::chrono::milliseconds timeout)
+```
+
+等待任务组中所有任务完成，可在超时后返回。
+
+**参数：**
+- `timeout` - 最大等待时间
+
+**返回：** `bool` - 所有任务在超时前完成返回 true，超时返回 false
+
+**复杂度：** O(n)
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+for (int i = 0; i < 5; ++i) {
+    group->AddTask([i]() {
+        Thread::Sleep(i * 100);
+        printf("Task %d done\n", i);
+    });
+}
+
+if (group->WaitFor(std::chrono::seconds(1))) {
+    printf("All tasks completed within 1 second\n");
+} else {
+    printf("Timeout! Some tasks still running\n");
+    printf("Progress: %.1f%%\n", group->GetProgress() * 100.0f);
+}
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览
+- [Wait](wait.md) - 无超时等待

docs/api/threading/task-system/createtaskgroup.md

@@ -0,0 +1,39 @@
+# TaskSystem::CreateTaskGroup
+
+```cpp
+TaskGroup* CreateTaskGroup()
+```
+
+创建一个任务组用于批量管理多个任务。
+
+**参数：** 无
+
+**返回：** `TaskGroup*` - 新创建的任务组指针
+
+**复杂度：** O(1)
+
+**注意：**
+- 任务组必须通过 DestroyTaskGroup 显式销毁。
+- 任务组的所有权归调用者，TaskSystem 不负责销毁。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+group->AddTask([]() { LoadTextures(); });
+group->AddTask([]() { LoadModels(); });
+group->AddTask([]() { LoadAudio(); });
+
+group->SetCompleteCallback([]() {
+    printf("All resources loaded!\n");
+});
+
+group->Wait();
+TaskSystem::Get().DestroyTaskGroup(group);
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览
+- [DestroyTaskGroup](destroytaskgroup.md) - 销毁任务组

docs/api/threading/task-system/destroytaskgroup.md

@@ -0,0 +1,32 @@
+# TaskSystem::DestroyTaskGroup
+
+```cpp
+void DestroyTaskGroup(TaskGroup* group)
+```
+
+销毁一个任务组并释放其资源。
+
+**参数：**
+- `group` - 要销毁的任务组指针
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：**
+- 销毁时如果还有未完成的任务，这些任务将被取消。
+- 传入 nullptr 无效果。
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+// ... 添加任务 ...
+
+TaskSystem::Get().DestroyTaskGroup(group);
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览
+- [CreateTaskGroup](createtaskgroup.md) - 创建任务组

docs/api/threading/task-system/get.md

@@ -0,0 +1,26 @@
+# TaskSystem::Get
+
+```cpp
+static TaskSystem& Get()
+```
+
+获取 TaskSystem 单例实例。第一次调用时创建单例。
+
+**参数：** 无
+
+**返回：** `TaskSystem&` - 单例实例的引用
+
+**复杂度：** O(1)
+
+**线程安全：** 线程安全
+
+**示例：**
+
+```cpp
+TaskSystem& system = TaskSystem::Get();
+system.Initialize(config);
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览

docs/api/threading/task-system/getworkerthreadcount.md

@@ -0,0 +1,25 @@
+# TaskSystem::GetWorkerThreadCount
+
+```cpp
+uint32_t GetWorkerThreadCount() const
+```
+
+获取工作线程的数量。
+
+**参数：** 无
+
+**返回：** `uint32_t` - 工作线程数量
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+TaskSystem::Get().Initialize(config);
+uint32_t count = TaskSystem::Get().GetWorkerThreadCount();
+printf("Worker threads: %u\n", count);
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览

docs/api/threading/task-system/initialize.md

@@ -0,0 +1,37 @@
+# TaskSystem::Initialize
+
+```cpp
+void Initialize(const TaskSystemConfig& config)
+```
+
+初始化任务系统，创建工作线程并启动任务调度。
+
+**参数：**
+- `config` - 任务系统配置（参见 TaskSystemConfig）
+
+**返回：** 无
+
+**复杂度：** O(n)，n 为 workerThreadCount
+
+**注意：**
+- 多次调用将先关闭已有系统再重新初始化。
+- 应在主线程中调用，在任何任务提交之前完成初始化。
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = std::thread::hardware_concurrency();
+config.enableTaskProfiling = true; // 预留配置项（当前未使用）
+config.stealTasks = true;          // 预留配置项（当前未实现）
+config.maxTaskQueueSize = 2048;     // 预留配置项（当前未强制限制）
+
+TaskSystem::Get().Initialize(config);
+printf("TaskSystem started with %u workers\n", 
+    TaskSystem::Get().GetWorkerThreadCount());
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览
+- [Shutdown](shutdown.md) - 关闭任务系统

docs/api/threading/task-system/parallelfor.md

@@ -0,0 +1,46 @@
+# TaskSystem::ParallelFor
+
+```cpp
+template<typename Func>
+void ParallelFor(int32_t start, int32_t end, Func&& func)
+```
+
+并行执行 for 循环。将循环范围划分为多个块，分配给多个工作线程并行处理。
+
+**模板参数：**
+- `Func` - 可调用对象类型，签名为 `void(int32_t)`
+
+**参数：**
+- `start` - 循环起始索引（包含）
+- `end` - 循环结束索引（不包含）
+- `func` - 对每个索引执行的函数
+
+**返回：** 无
+
+**复杂度：** O(n)
+
+**分区策略：**
+- 根据 `std::thread::hardware_concurrency()` 确定线程数。
+- 将范围均分给各线程，每个线程处理连续的块。
+
+**示例：**
+
+```cpp
+// 并行处理 10000 个元素
+std::vector<float> data(10000, 0.0f);
+
+TaskSystem::Get().ParallelFor(0, 10000, [&data](int32_t i) {
+    data[i] = std::sin(i * 0.01f) * std::cos(i * 0.007f);
+});
+
+// 并行矩阵乘法
+TaskSystem::Get().ParallelFor(0, N, [&matrix](int32_t row) {
+    for (int32_t col = 0; col < N; ++col) {
+        matrix[row * N + col] = Compute(row, col);
+    }
+});
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览

docs/api/threading/task-system/runonmainthread.md

@@ -0,0 +1,43 @@
+# TaskSystem::RunOnMainThread
+
+```cpp
+void RunOnMainThread(std::function<void()>&& func)
+```
+
+将任务提交到主线程队列。在主线程中调用 Update 时执行。
+
+**参数：**
+- `func` - 要在主线程执行的函数
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**使用场景：**
+- 从工作线程回调需要更新 UI 或访问主线程资源。
+- 避免跨线程数据竞争。
+
+**示例：**
+
+```cpp
+// 在工作线程中
+void WorkerThreadCode() {
+    int result = HeavyCompute();
+    
+    // 将结果发送到主线程更新 UI
+    TaskSystem::Get().RunOnMainThread([result]() {
+        UI.UpdateResult(result);
+    });
+}
+
+// 在主线程中
+while (running) {
+    TaskSystem::Get().Update(); // 处理主线程任务
+    RenderFrame();
+}
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览
+- [Update](update.md) - 处理主线程队列

docs/api/threading/task-system/shutdown.md

@@ -0,0 +1,33 @@
+# TaskSystem::Shutdown
+
+```cpp
+void Shutdown()
+```
+
+关闭任务系统，停止所有工作线程并清理资源。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(n)
+
+**注意：**
+- 调用后应等待所有提交的任务执行完毕，或确保不再需要未完成的任务。
+- 关闭后不可再次使用，必须重新 Initialize。
+
+**示例：**
+
+```cpp
+TaskSystem::Get().Initialize(config);
+
+// ... 使用任务系统 ...
+
+TaskSystem::Get().Shutdown();
+printf("TaskSystem stopped\n");
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览
+- [Initialize](initialize.md) - 初始化任务系统

docs/api/threading/task-system/submit.md

@@ -0,0 +1,63 @@
+# TaskSystem::Submit
+
+将任务提交到任务系统调度执行。有两个重载版本。
+
+## 重载 1: 提交 ITask 对象
+
+```cpp
+uint64_t Submit(std::unique_ptr<ITask> task)
+```
+
+提交一个 ITask 对象到任务队列。
+
+**参数：**
+- `task` - 要提交的任务对象
+
+**返回：** `uint64_t` - 分配的任务 ID
+
+**复杂度：** O(log n)
+
+## 重载 2: 提交 lambda 任务
+
+```cpp
+uint64_t Submit(std::function<void()>&& func, TaskPriority priority = TaskPriority::Normal)
+```
+
+将可调用对象包装为任务提交。
+
+**参数：**
+- `func` - 要执行的可调用对象
+- `priority` - 任务优先级，默认 TaskPriority::Normal
+
+**返回：** `uint64_t` - 分配的任务 ID
+
+**复杂度：** O(log n)
+
+**示例：**
+
+```cpp
+// 提交自定义任务
+class MyTask : public ITask {
+public:
+    void Execute() override { printf("MyTask running\n"); }
+};
+uint64_t id1 = TaskSystem::Get().Submit(std::make_unique<MyTask>());
+
+// 提交 lambda
+uint64_t id2 = TaskSystem::Get().Submit([]() {
+    printf("Lambda task\n");
+});
+
+uint64_t id3 = TaskSystem::Get().Submit([]() {
+    HeavyCompute();
+}, TaskPriority::High);
+
+// 等待任务完成
+TaskSystem::Get().Wait(id1);
+TaskSystem::Get().Wait(id2);
+TaskSystem::Get().Wait(id3);
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览

docs/api/threading/task-system/task-system.md

@@ -0,0 +1,82 @@
+# TaskSystem
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class` (singleton)
+
+**头文件**: `XCEngine/Threading/TaskSystem.h`
+
+**描述**: 并行任务调度系统单例，提供优先级任务队列。
+
+## 概述
+
+`TaskSystem` 是 XCEngine 的核心并行任务调度系统。它创建多个工作线程，使用优先级队列调度任务。它还提供 `ParallelFor` 方法用于数据级并行，以及主线程任务队列。
+
+**注意：** 当前实现的 `stealTasks` 配置项未生效，任务系统使用单一全局任务队列而非工作窃取模式。
+
+## 单例访问
+
+| 方法 | 描述 |
+|------|------|
+| [`Get`](get.md) | 获取单例实例 |
+
+## 公共方法
+
+| 方法 | 描述 |
+|------|------|
+| [`Get`](get.md) | 获取单例实例 |
+| [`Initialize`](initialize.md) | 初始化任务系统 |
+| [`Shutdown`](shutdown.md) | 关闭任务系统 |
+| [`Submit(unique_ptr)`](submit.md) | 提交任务对象 |
+| [`Submit(callback)`](submit.md) | 提交 lambda 任务 |
+| [`CreateTaskGroup`](createtaskgroup.md) | 创建任务组 |
+| [`DestroyTaskGroup`](destroytaskgroup.md) | 销毁任务组 |
+| [`Wait`](wait.md) | 等待指定任务完成（当前为空实现） |
+| [`GetWorkerThreadCount`](getworkerthreadcount.md) | 获取工作线程数量 |
+| [`ParallelFor`](parallelfor.md) | 并行执行 for 循环 |
+| [`RunOnMainThread`](runonmainthread.md) | 将任务提交到主线程执行 |
+| [`Update`](update.md) | 在主线程中处理主线程队列 |
+
+## 使用示例
+
+```cpp
+// 初始化（4 个工作线程）
+TaskSystemConfig config;
+config.workerThreadCount = 4;
+TaskSystem::Get().Initialize(config);
+
+// 提交任务
+TaskSystem::Get().Submit([]() {
+    printf("Task 1 running\n");
+});
+
+TaskSystem::Get().Submit([]() {
+    printf("Task 2 running\n");
+}, TaskPriority::High);
+
+// 并行 for
+TaskSystem::Get().ParallelFor(0, 1000, [](int32_t i) {
+    process(i);
+});
+
+// 主线程任务
+TaskSystem::Get().RunOnMainThread([]() {
+    // 更新 UI 或其他主线程操作
+});
+
+// 主循环中调用 Update
+while (running) {
+    TaskSystem::Get().Update();  // 处理主线程任务
+}
+
+// 关闭
+TaskSystem::Get().Shutdown();
+```
+
+## 相关文档
+
+- [ITask](../task/task.md) - 任务基类
+- [LambdaTask](../lambdatask/lambdatask.md) - Lambda 任务
+- [TaskGroup](../task-group/task-group.md) - 任务组
+- [TaskSystemConfig](../tasksystemconfig/tasksystemconfig.md) - 配置
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/task-system/update.md

@@ -0,0 +1,36 @@
+# TaskSystem::Update
+
+```cpp
+void Update()
+```
+
+在主线程中处理主线程队列。执行所有通过 RunOnMainThread 提交的任务。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(n)，n 为队列中待执行任务数
+
+**使用场景：**
+- 在主循环中调用，确保 RunOnMainThread 提交的任务能够执行。
+- 应在渲染前调用。
+
+**示例：**
+
+```cpp
+// 主循环
+while (application.IsRunning()) {
+    TaskSystem::Get().Update();  // 处理主线程任务
+    
+    // 渲染
+    Renderer.BeginFrame();
+    RenderScene();
+    Renderer.EndFrame();
+}
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览
+- [RunOnMainThread](runonmainthread.md) - 提交主线程任务

docs/api/threading/task-system/wait.md

@@ -0,0 +1,37 @@
+# TaskSystem::Wait
+
+```cpp
+void Wait(uint64_t taskId)
+```
+
+**注意：** 此方法当前为空实现，不执行任何操作。
+
+**参数：**
+- `taskId` - 要等待的任务 ID
+
+**返回：** 无
+
+**复杂度：** N/A（空实现）
+
+**当前状态：** 此方法为空实现，不执行任何操作。任务系统目前不支持按任务 ID 等待。
+
+**建议：** 使用 `TaskGroup::Wait` 代替此方法。
+
+**示例：**
+
+```cpp
+uint64_t id = TaskSystem::Get().Submit([]() {
+    for (int i = 0; i < 1000000; ++i) {
+        Compute(i);
+    }
+});
+
+printf("Waiting for task...\n");
+// 注意：当前实现为空，建议使用 TaskGroup 来等待任务完成
+TaskSystem::Get().Wait(id);
+printf("Task completed\n");
+```
+
+## 相关文档
+
+- [TaskSystem 总览](task-system.md) - 返回类总览

docs/api/threading/task/addref.md

@@ -0,0 +1,27 @@
+# ITask::AddRef
+
+```cpp
+void AddRef()
+```
+
+增加任务的引用计数。用于延长任务的生命周期，使其不会被自动释放。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+ITask* task = new MyTask();
+task->AddRef(); // 保持引用，不会在 Release 时被删除
+task->SetPriority(TaskPriority::High);
+TaskSystem::Get().Submit(std::unique_ptr<ITask>(task));
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览
+- [Release](release.md) - 释放引用计数

docs/api/threading/task/execute.md

@@ -0,0 +1,43 @@
+# ITask::Execute
+
+```cpp
+virtual void Execute() = 0
+```
+
+任务执行逻辑（纯虚方法）。用户必须在派生类中实现此方法以定义任务的具体行为。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 取决于具体任务实现
+
+**注意：**
+- 此方法由 TaskSystem 的工作线程调用。
+- 任务执行期间如发生未捕获异常，行为未定义。
+
+**示例：**
+
+```cpp
+class ComputeTask : public ITask {
+public:
+    explicit ComputeTask(int n) : m_n(n) {}
+    
+    void Execute() override {
+        int result = 0;
+        for (int i = 0; i < m_n; ++i) {
+            result += i;
+        }
+        printf("Result: %d\n", result);
+    }
+    
+private:
+    int m_n;
+};
+
+TaskSystem::Get().Submit(std::make_unique<ComputeTask>(100));
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/getid.md

@@ -0,0 +1,25 @@
+# ITask::GetId
+
+```cpp
+uint64_t GetId() const
+```
+
+获取任务的唯一标识符。
+
+**参数：** 无
+
+**返回：** `uint64_t` - 任务的唯一 ID
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+ITask* task = /* ... */;
+uint64_t id = task->GetId();
+printf("Task ID: %llu\n", (unsigned long long)id);
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/getpriority.md

@@ -0,0 +1,27 @@
+# ITask::GetPriority
+
+```cpp
+TaskPriority GetPriority() const
+```
+
+获取任务的优先级。
+
+**参数：** 无
+
+**返回：** `TaskPriority` - 当前任务的优先级
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+ITask* task = /* ... */;
+TaskPriority priority = task->GetPriority();
+if (priority == TaskPriority::Critical) {
+    printf("Critical task\n");
+}
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/getstatus.md

@@ -0,0 +1,32 @@
+# ITask::GetStatus
+
+```cpp
+TaskStatus GetStatus() const
+```
+
+获取任务的当前状态。
+
+**参数：** 无
+
+**返回：** `TaskStatus` - 当前任务状态
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+ITask* task = /* ... */;
+TaskStatus status = task->GetStatus();
+switch (status) {
+    case TaskStatus::Pending:   printf("Pending\n"); break;
+    case TaskStatus::Scheduled: printf("Scheduled\n"); break;
+    case TaskStatus::Running:   printf("Running\n"); break;
+    case TaskStatus::Completed: printf("Completed\n"); break;
+    case TaskStatus::Failed:   printf("Failed\n"); break;
+    case TaskStatus::Canceled:  printf("Canceled\n"); break;
+}
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/oncancel.md

@@ -0,0 +1,38 @@
+# ITask::OnCancel
+
+```cpp
+virtual void OnCancel()
+```
+
+任务取消回调。可在派生类中重写此方法，以在任务被取消时执行清理操作。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 取决于具体实现
+
+**示例：**
+
+```cpp
+class NetworkTask : public ITask {
+public:
+    void Execute() override {
+        for (int i = 0; i < 100; ++i) {
+            if (GetStatus() == TaskStatus::Canceled) {
+                return;
+            }
+            SendPacket(i);
+        }
+    }
+    
+    void OnCancel() override {
+        CloseConnection();
+        printf("Network task canceled\n");
+    }
+};
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/oncomplete.md

@@ -0,0 +1,39 @@
+# ITask::OnComplete
+
+```cpp
+virtual void OnComplete()
+```
+
+任务完成回调。可在派生类中重写此方法，以在任务执行完毕后执行清理或后续操作。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** 取决于具体实现
+
+**示例：**
+
+```cpp
+class DataLoadTask : public ITask {
+public:
+    explicit DataLoadTask(const String& path) : m_path(path) {}
+    
+    void Execute() override {
+        m_data = LoadFromFile(m_path);
+    }
+    
+    void OnComplete() override {
+        printf("Data loaded, size: %zu\n", m_data.Size());
+        ProcessData(m_data);
+    }
+    
+private:
+    String m_path;
+    Containers::Vector<uint8_t> m_data;
+};
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/release.md

@@ -0,0 +1,32 @@
+# ITask::Release
+
+```cpp
+void Release()
+```
+
+减少引用计数。当引用计数归零时，对象会自动 delete 自身。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：**
+- 任务提交给 TaskSystem 后，TaskSystem 会自动管理引用计数。
+- 当任务完成且无人持有引用时，任务对象将被自动销毁。
+- 不要在任务执行过程中调用 Release。
+
+**示例：**
+
+```cpp
+ITask* task = new MyTask();
+task->AddRef(); // 引用计数 = 2
+TaskSystem::Get().Submit(std::unique_ptr<ITask>(task)); // 引用计数 = 1
+task->Release(); // 引用计数 = 0，任务被 delete
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览
+- [AddRef](addref.md) - 增加引用计数

docs/api/threading/task/setid.md

@@ -0,0 +1,28 @@
+# ITask::SetId
+
+```cpp
+void SetId(uint64_t id)
+```
+
+设置任务的唯一标识符。通常由 TaskSystem 在提交时自动分配。
+
+**参数：**
+- `id` - 要设置的唯一标识符
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+class MyTask : public ITask {
+public:
+    MyTask() { SetId(GenerateId()); }
+    void Execute() override { /* ... */ }
+};
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/setpriority.md

@@ -0,0 +1,28 @@
+# ITask::SetPriority
+
+```cpp
+void SetPriority(TaskPriority priority)
+```
+
+设置任务的优先级。
+
+**参数：**
+- `priority` - 新的优先级（参见 TaskPriority 枚举）
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：** 任务提交后修改优先级可能不会立即生效，取决于任务系统实现。
+
+**示例：**
+
+```cpp
+auto task = std::make_unique<MyTask>();
+task->SetPriority(TaskPriority::High);
+TaskSystem::Get().Submit(std::move(task));
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/setstatus.md

@@ -0,0 +1,35 @@
+# ITask::SetStatus
+
+```cpp
+void SetStatus(TaskStatus status)
+```
+
+设置任务的当前状态。
+
+**参数：**
+- `status` - 新的状态（参见 TaskStatus 枚举）
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：** 正常情况下由 TaskSystem 管理状态。手动设置状态可能干扰任务系统的正常调度。
+
+**示例：**
+
+```cpp
+class ConditionalTask : public ITask {
+public:
+    void Execute() override {
+        if (someCondition) {
+            SetStatus(TaskStatus::Failed);
+            return;
+        }
+        // 正常处理
+    }
+};
+```
+
+## 相关文档
+
+- [ITask 总览](task.md) - 返回类总览

docs/api/threading/task/task.md

@@ -0,0 +1,88 @@
+# ITask
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class` (abstract)
+
+**头文件**: `XCEngine/Threading/Task.h`
+
+**描述**: 任务基类抽象接口和任务状态/优先级枚举定义。
+
+## 概述
+
+`ITask` 是任务系统的核心抽象基类。用户需要继承此类并实现 `Execute()` 方法来定义具体的任务逻辑。任务系统通过引用计数自动管理任务生命周期。
+
+## TaskPriority 枚举
+
+任务优先级枚举（数值越小优先级越高）。
+
+| 值 | 描述 |
+|----|------|
+| `Critical` | 关键优先级（0） |
+| `High` | 高优先级（1） |
+| `Normal` | 普通优先级（2） |
+| `Low` | 低优先级（3） |
+| `Idle` | 空闲优先级（4） |
+
+## TaskStatus 枚举
+
+任务状态枚举。
+
+| 值 | 描述 |
+|----|------|
+| `Pending` | 等待中 |
+| `Scheduled` | 已调度 |
+| `Running` | 运行中 |
+| `Completed` | 已完成 |
+| `Failed` | 失败 |
+| `Canceled` | 已取消 |
+
+## 公共方法
+
+| 方法 | 描述 |
+|------|------|
+| `virtual ~ITask()` | 虚析构函数 |
+| `ITask()` | 默认构造函数（受保护） |
+| `ITask(TaskPriority priority)` | 带优先级的构造函数（受保护） |
+| [`Execute`](execute.md) | 任务执行逻辑（纯虚） |
+| [`OnComplete`](oncomplete.md) | 任务完成回调（可重写） |
+| [`OnCancel`](oncancel.md) | 任务取消回调（可重写） |
+| [`GetPriority`](getpriority.md) | 获取优先级 |
+| [`GetStatus`](getstatus.md) | 获取状态 |
+| [`GetId`](getid.md) | 获取任务 ID |
+| [`SetId`](setid.md) | 设置任务 ID |
+| [`SetPriority`](setpriority.md) | 设置优先级 |
+| [`SetStatus`](setstatus.md) | 设置状态 |
+| [`AddRef`](addref.md) | 增加引用计数 |
+| [`Release`](release.md) | 减少引用计数（引用归零时自动 delete） |
+
+## 使用示例
+
+```cpp
+class MyTask : public ITask {
+public:
+    explicit MyTask(int data) : m_data(data) {}
+    
+    void Execute() override {
+        printf("Task executed with data: %d\n", m_data);
+    }
+    
+    void OnComplete() override {
+        printf("Task completed\n");
+    }
+    
+private:
+    int m_data;
+};
+
+auto task = new MyTask(42);
+task->SetPriority(TaskPriority::High);
+TaskSystem::Get().Submit(std::unique_ptr<ITask>(task));
+```
+
+## 相关文档
+
+- [LambdaTask](../lambdatask/lambdatask.md) - Lambda 任务封装
+- [TaskGroup](../task-group/task-group.md) - 任务组
+- [TaskSystem](../task-system/task-system.md) - 任务系统
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/tasksystemconfig/enabletaskprofiling.md

@@ -0,0 +1,29 @@
+# TaskSystemConfig::enableTaskProfiling
+
+```cpp
+bool enableTaskProfiling = true
+```
+
+是否启用任务性能分析。启用后系统会记录任务的执行时间、等待时间等统计信息，可用于性能调试。
+
+**类型：** `bool`
+
+**默认值：** `true`
+
+**当前状态：** 此配置项当前未实际使用，任务系统不会记录性能分析数据。
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = 4;
+config.enableTaskProfiling = true; // 预留配置项
+
+#ifdef NDEBUG
+config.enableTaskProfiling = false; // 预留配置项
+#endif
+```
+
+## 相关文档
+
+- [TaskSystemConfig 总览](tasksystemconfig.md) - 返回类总览

docs/api/threading/tasksystemconfig/maxtaskqueuesize.md

@@ -0,0 +1,24 @@
+# TaskSystemConfig::maxTaskQueueSize
+
+```cpp
+uint32_t maxTaskQueueSize = 1024
+```
+
+任务队列的最大容量。当队列满时，新提交的任务将阻塞直到有空间。
+
+**类型：** `uint32_t`
+
+**默认值：** `1024`
+
+**当前状态：** 此配置项当前未实际强制限制，任务队列可以无限增长（受系统内存限制）。
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.maxTaskQueueSize = 4096; // 预留配置项（当前未强制限制）
+```
+
+## 相关文档
+
+- [TaskSystemConfig 总览](tasksystemconfig.md) - 返回类总览

docs/api/threading/tasksystemconfig/stealtasks.md

@@ -0,0 +1,25 @@
+# TaskSystemConfig::stealTasks
+
+```cpp
+bool stealTasks = true
+```
+
+是否启用工作窃取。当启用时，空闲的工作线程可以从其他繁忙线程的任务队列中窃取任务，提高整体吞吐率。
+
+**类型：** `bool`
+
+**默认值：** `true`
+
+**当前状态：** 此配置项当前未实际实现，工作窃取功能不可用。所有工作线程仅从全局任务队列获取任务。
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = 8;
+config.stealTasks = true; // 预留配置项（当前未实现）
+```
+
+## 相关文档
+
+- [TaskSystemConfig 总览](tasksystemconfig.md) - 返回类总览

docs/api/threading/tasksystemconfig/tasksystemconfig.md

@@ -0,0 +1,36 @@
+# TaskSystemConfig
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `struct`
+
+**头文件**: `XCEngine/Threading/TaskSystemConfig.h`
+
+**描述**: 任务系统配置结构体，用于初始化 TaskSystem 的行为参数。
+
+## 结构体成员
+
+| 成员 | 类型 | 描述 | 默认值 |
+|------|------|------|--------|
+| [`workerThreadCount`](workerthreadcount.md) | `uint32_t` | 工作线程数量（0=自动检测 CPU 核心数） | 0 |
+| [`enableTaskProfiling`](enabletaskprofiling.md) | `bool` | 启用任务性能分析（当前未使用） | true |
+| [`stealTasks`](stealtasks.md) | `bool` | 启用工作窃取（当前未实现） | true |
+| [`maxTaskQueueSize`](maxtaskqueuesize.md) | `uint32_t` | 最大任务队列大小（当前未强制限制） | 1024 |
+| [`threadStackSize`](threadstacksize.md) | `uint32_t` | 线程栈大小（当前未使用，0=系统默认） | 0 |
+
+## 使用示例
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = std::thread::hardware_concurrency();
+config.enableTaskProfiling = true;
+config.stealTasks = true;
+config.maxTaskQueueSize = 2048;
+
+TaskSystem::Get().Initialize(config);
+```
+
+## 相关文档
+
+- [TaskSystem](../task-system/task-system.md) - 任务系统
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/tasksystemconfig/threadstacksize.md

@@ -0,0 +1,28 @@
+# TaskSystemConfig::threadStackSize
+
+```cpp
+uint32_t threadStackSize = 0
+```
+
+工作线程的栈大小（字节）。值为 0 时使用系统默认值。
+
+**类型：** `uint32_t`
+
+**默认值：** `0`（使用系统默认）
+
+**当前状态：** 此配置项当前未实际使用，工作线程始终使用系统默认栈大小。
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = 4;
+config.threadStackSize = 1024 * 1024; // 预留配置项（当前未实现）
+
+TaskSystemConfig defaultConfig;
+defaultConfig.threadStackSize = 0; // 使用系统默认
+```
+
+## 相关文档
+
+- [TaskSystemConfig 总览](tasksystemconfig.md) - 返回类总览

docs/api/threading/tasksystemconfig/workerthreadcount.md

@@ -0,0 +1,25 @@
+# TaskSystemConfig::workerThreadCount
+
+```cpp
+uint32_t workerThreadCount = 0
+```
+
+工作线程数量。当值为 0 时，任务系统自动检测 `std::thread::hardware_concurrency()` 并使用该值。
+
+**类型：** `uint32_t`
+
+**默认值：** `0`（自动检测）
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = 4; // 使用 4 个工作线程
+
+TaskSystemConfig autoConfig;
+autoConfig.workerThreadCount = 0; // 自动检测（推荐）
+```
+
+## 相关文档
+
+- [TaskSystemConfig 总览](tasksystemconfig.md) - 返回类总览

docs/api/threading/thread/detach.md

@@ -0,0 +1,38 @@
+# Thread::Detach
+
+```cpp
+void Detach()
+```
+
+分离线程，使其成为后台线程独立运行。分离后，线程的资源将在其终止时自动释放，调用线程不会被阻塞。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**注意：**
+- 分离后的线程无法再被 Join 或进行任何同步操作。
+- 确保分离线程的所有资源访问都是线程安全的，因为主线程可能在分离线程结束前退出。
+- 如果 Thread 对象在分离线程结束前被销毁，行为取决于具体实现。
+
+**示例：**
+
+```cpp
+Thread background;
+background.Start([]() {
+    printf("Background task running\n");
+    for (int i = 0; i < 3; ++i) {
+        Thread::Sleep(500);
+        printf("Background: tick %d\n", i);
+    }
+}, "BackgroundThread");
+
+background.Detach();
+printf("Main thread continues immediately\n");
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览

docs/api/threading/thread/getcurrentid.md

@@ -0,0 +1,30 @@
+# Thread::GetCurrentId
+
+```cpp
+static Id GetCurrentId()
+```
+
+获取当前执行线程的唯一标识符。这是一个静态方法，可以在任何线程上下文中调用。
+
+**参数：** 无
+
+**返回：** `Thread::Id` - 当前执行线程的唯一标识符
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+Thread worker;
+worker.Start([]() {
+    printf("Worker thread id: %llu\n", (unsigned long long)Thread::GetCurrentId());
+}, "WorkerThread");
+
+printf("Main thread id: %llu\n", (unsigned long long)Thread::GetCurrentId());
+worker.Join();
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览
+- [GetId](getid.md) - 获取 Thread 对象的 ID

docs/api/threading/thread/getid.md

@@ -0,0 +1,30 @@
+# Thread::GetId
+
+```cpp
+Id GetId() const
+```
+
+获取当前线程对象的唯一标识符。该 ID 在线程启动后有效。
+
+**参数：** 无
+
+**返回：** `Thread::Id` - 线程的唯一标识符（uint64_t 类型）
+
+**复杂度：** O(1)
+
+**注意：** 在调用 Start 之前返回 0。
+
+**示例：**
+
+```cpp
+Thread worker;
+printf("Before start: id=%llu\n", (unsigned long long)worker.GetId());
+worker.Start([]() {}, "Test");
+printf("After start: id=%llu\n", (unsigned long long)worker.GetId());
+worker.Join();
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览
+- [GetCurrentId](getcurrentid.md) - 获取当前执行线程的 ID

docs/api/threading/thread/getname.md

@@ -0,0 +1,28 @@
+# Thread::GetName
+
+```cpp
+const Containers::String& GetName() const
+```
+
+获取线程的名称。该名称在调用 Start 时设置。
+
+**参数：** 无
+
+**返回：** `const Containers::String&` - 线程名称的引用
+
+**复杂度：** O(1)
+
+**注意：** 在调用 Start 之前返回空字符串。
+
+**示例：**
+
+```cpp
+Thread worker;
+worker.Start([]() {}, "ComputeThread");
+printf("Thread name: %s\n", worker.GetName().CStr());
+worker.Join();
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览

docs/api/threading/thread/join.md

@@ -0,0 +1,37 @@
+# Thread::Join
+
+```cpp
+void Join()
+```
+
+等待线程结束并回收其资源。调用线程将被阻塞，直到目标线程完成执行。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(n)，n 为目标线程的执行时间
+
+**注意：**
+- 如果线程已经被分离（Detach）或已经 Join 过，调用此方法将导致未定义行为。
+- 建议在使用完 Thread 对象后始终调用 Join 或 Detach。
+
+**示例：**
+
+```cpp
+Thread worker;
+worker.Start([]() {
+    for (int i = 0; i < 5; ++i) {
+        printf("Working...\n");
+        Thread::Sleep(100);
+    }
+}, "WorkerThread");
+
+printf("Main thread waiting...\n");
+worker.Join();
+printf("Worker thread finished\n");
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览

docs/api/threading/thread/sleep.md

@@ -0,0 +1,30 @@
+# Thread::Sleep
+
+```cpp
+static void Sleep(uint32_t milliseconds)
+```
+
+使当前线程休眠指定的时间。线程在休眠期间不会消耗 CPU 时间。
+
+**参数：**
+- `milliseconds` - 休眠时间，以毫秒为单位
+
+**返回：** 无
+
+**复杂度：** 取决于操作系统的调度精度，通常为 O(milliseconds)
+
+**示例：**
+
+```cpp
+printf("Start\n");
+Thread::Sleep(1000); // 休眠1秒
+printf("After 1 second\n");
+
+Thread::Sleep(500); // 再休眠0.5秒
+printf("After 0.5 more seconds\n");
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览
+- [Yield](yield.md) - 让出时间片

docs/api/threading/thread/start.md

@@ -0,0 +1,37 @@
+# Thread::Start
+
+```cpp
+template<typename Func>
+void Start(Func&& func, const Containers::String& name = "Thread")
+```
+
+启动线程，执行传入的可调用对象。该方法创建一个新的执行线程，立即开始运行。
+
+**参数：**
+- `func` - 要在线程中执行的可调用对象（lambda、函数指针、仿函数等）
+- `name` - 线程名称，用于调试和日志输出，默认值为 "Thread"
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**线程安全：** 该方法不是线程安全的，不应在同一 Thread 对象上并发调用。
+
+**示例：**
+
+```cpp
+#include "Threading/Thread.h"
+
+Thread worker;
+worker.Start([]() {
+    printf("Worker thread running\n");
+    Thread::Sleep(100);
+    printf("Worker thread done\n");
+}, "WorkerThread");
+
+worker.Join();
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览

docs/api/threading/thread/thread.md

@@ -0,0 +1,60 @@
+# Thread
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `class`
+
+**头文件**: `XCEngine/Threading/Thread.h`
+
+**描述**: 线程封装类，提供跨平台线程创建和管理功能。
+
+## 概述
+
+`Thread` 类封装了 `std::thread`，提供统一的线程管理接口，包括启动、加入、分离等操作。
+
+## 公共类型
+
+| 类型 | 描述 |
+|------|------|
+| `using Id = uint64_t` | 线程唯一标识符类型 |
+
+## 公共方法
+
+| 方法 | 描述 |
+|------|------|
+| `Thread()` | 默认构造函数 |
+| `~Thread()` | 析构函数 |
+| [`Start`](start.md) | 启动线程，执行传入的函数 |
+| [`Join`](join.md) | 等待线程结束 |
+| [`Detach`](detach.md) | 分离线程，使其独立运行 |
+| [`GetId`](getid.md) | 获取线程 ID |
+| [`GetName`](getname.md) | 获取线程名称 |
+| [`GetCurrentId`](getcurrentid.md) | 获取当前线程 ID |
+| [`Sleep`](sleep.md) | 线程休眠指定毫秒数 |
+| [`Yield`](yield.md) | 让出当前线程的时间片 |
+
+## 使用示例
+
+```cpp
+#include "Threading/Thread.h"
+
+// 创建并启动线程
+Thread thread;
+thread.Start([]() {
+    printf("Worker thread running\n");
+}, "WorkerThread");
+
+// 等待线程结束
+thread.Join();
+
+// 使用静态方法
+Thread::Sleep(1000); // 休眠1秒
+Thread::Yield();      // 让出时间片
+auto currentId = Thread::GetCurrentId();
+```
+
+## 相关文档
+
+- [Mutex](../mutex/mutex.md) - 互斥锁
+- [TaskSystem](../task-system/task-system.md) - 任务调度系统
+- [../threading/threading.md](../threading.md) - 模块总览

docs/api/threading/thread/yield.md

@@ -0,0 +1,40 @@
+# Thread::Yield
+
+```cpp
+static void Yield()
+```
+
+让出当前线程的时间片，允许操作系统调度器将 CPU 时间分配给其他就绪线程。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(1)
+
+**使用场景：**
+- 在自旋等待某个条件时调用，避免浪费 CPU 周期。
+- 在长时间循环中定期让出时间片，提高其他线程的响应性。
+
+**示例：**
+
+```cpp
+volatile bool ready = false;
+
+Thread worker;
+worker.Start([]() {
+    ready = true;
+}, "WorkerThread");
+
+// 忙等待，但定期让出时间片
+while (!ready) {
+    Thread::Yield();
+}
+
+worker.Join();
+```
+
+## 相关文档
+
+- [Thread 总览](thread.md) - 返回类总览
+- [Sleep](sleep.md) - 线程休眠

docs/api/threading/threading.md

@@ -0,0 +1,74 @@
+# Threading 模块概览
+
+**命名空间**: `XCEngine::Threading`
+
+**类型**: `module`
+
+**描述**: XCEngine 的线程和并发模块，提供多线程编程所需的同步原语和任务系统。
+
+## 概述
+
+Threading 模块提供了一套完整的多线程编程工具，包括线程封装、同步原语和并行任务系统。
+
+## 模块内容
+
+### 同步原语
+
+| 组件 | 文件 | 描述 |
+|------|------|------|
+| [Mutex](mutex/mutex.md) | `Mutex.h` | 互斥锁 |
+| [SpinLock](spinlock/spinlock.md) | `SpinLock.h` | 自旋锁 |
+| [ReadWriteLock](readwritelock/readwritelock.md) | `ReadWriteLock.h` | 读写锁 |
+
+### 线程
+
+| 组件 | 文件 | 描述 |
+|------|------|------|
+| [Thread](thread/thread.md) | `Thread.h` | 线程封装类 |
+
+### 任务系统
+
+| 组件 | 文件 | 描述 |
+|------|------|------|
+| [ITask](task/task.md) | `Task.h` | 任务基类 |
+| [LambdaTask](lambdatask/lambdatask.md) | `LambdaTask.h` | Lambda 任务封装模板 |
+| [TaskGroup](task-group/task-group.md) | `TaskGroup.h` | 任务组 |
+| [TaskSystem](task-system/task-system.md) | `TaskSystem.h` | 并行任务调度系统 |
+| [TaskSystemConfig](tasksystemconfig/tasksystemconfig.md) | `TaskSystemConfig.h` | 任务系统配置 |
+
+## 同步原语对比
+
+| 原语 | 适用场景 | 特点 |
+|------|----------|------|
+| `Mutex` | 一般互斥 | 可重入性差，开销适中 |
+| `SpinLock` | 短临界区 | 无系统调用，开销低 |
+| `ReadWriteLock` | 读多写少 | 读写分离，提高并发 |
+
+## 任务系统使用示例
+
+```cpp
+#include "Threading/TaskSystem.h"
+
+// 初始化任务系统
+TaskSystemConfig config;
+config.workerThreadCount = 4;
+TaskSystem::Get().Initialize(config);
+
+// 提交并行任务
+TaskSystem::Get().Submit([]() {
+    // 执行工作
+});
+
+// 使用任务组
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+group->AddTask([]() { /* 任务1 */ });
+group->AddTask([]() { /* 任务2 */ });
+group->Wait();
+
+// 销毁任务组
+TaskSystem::Get().DestroyTaskGroup(group);
+```
+
+## 相关文档
+
+- [Memory 模块](../memory/memory.md) - 内存分配器