docs: 重构 API 文档结构并修正源码准确性

- 重组文档目录结构: 每个模块的概述页移动到模块子目录
- 重命名 index.md 为 main.md
- 修正所有模块文档中的错误:
  - math: FromEuler→FromEulerAngles, TransformDirection 包含缩放, Box 是 OBB, Color::ToRGBA 格式
  - containers: 新增 operator==/!= 文档, 补充 std::hash DJB 算法细节
  - core: 修复 types 链接错误
  - debug: LogLevelToString 返回大写, timestamp 是秒, Profiler 空实现标注, Windows API vs ANSI
  - memory: 修复头文件路径, malloc vs operator new, 新增方法文档
  - resources: 修复 Shader/Texture 链接错误
  - threading: TaskSystem::Wait 空实现标注, ReadWriteLock 重入描述, LambdaTask 链接
- 验证: fix_links.py 确认 0 个断裂引用

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

@@ -4,6 +4,8 @@
 
 **类型**: `class` (template)
 
+**头文件**: `XCEngine/Threading/LambdaTask.h`
+
 **描述**: Lambda 任务封装模板类，允许使用 lambda 表达式创建任务，无需继承 ITask。
 
 ## 概述
@@ -20,7 +22,7 @@
 
 | 方法 | 描述 |
 |------|------|
-| `explicit LambdaTask(Func&& func, TaskPriority priority = TaskPriority::Normal)` | 构造 Lambda 任务 |
+| [`LambdaTask`](constructor.md) | 构造 Lambda 任务 |
 
 ## 使用示例
 
@@ -39,15 +41,11 @@ TaskSystem::Get().Submit(
 TaskSystem::Get().Submit([]() {
     printf("Direct lambda task!\n");
 });
-
-// 带依赖的任务
-TaskSystem::Get().Submit<std::function<void()>>([]() {
-    // 任务内容
-}, TaskPriority::High);
 ```
 
 ## 相关文档
 
-- [ITask](./threading-task.md) - 任务基类
-- [TaskGroup](./threading-task-group.md) - 任务组
-- [TaskSystem](./threading-task-system.md) - 任务系统
+- [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

@@ -4,6 +4,8 @@
 
 **类型**: `class`
 
+**头文件**: `XCEngine/Threading/Mutex.h`
+
 **描述**: 互斥锁封装类，基于 `std::mutex` 实现，提供线程安全的互斥访问。
 
 ## 概述
@@ -14,9 +16,9 @@
 
 | 方法 | 描述 |
 |------|------|
-| `void Lock()` | 获取锁（阻塞） |
-| `void Unlock()` | 释放锁 |
-| `bool TryLock()` | 尝试获取锁（非阻塞，成功返回 true） |
+| [`Lock`](lock.md) | 获取锁（阻塞） |
+| [`Unlock`](unlock.md) | 释放锁 |
+| [`TryLock`](trylock.md) | 尝试获取锁（非阻塞，成功返回 true） |
 
 ## STL 兼容方法
 
@@ -46,6 +48,7 @@ void SafeTryIncrement() {
 
 ## 相关文档
 
-- [SpinLock](./threading-spinlock.md) - 自旋锁
-- [ReadWriteLock](./threading-readwritelock.md) - 读写锁
-- [TaskSystem](./threading-task-system.md) - 任务系统
+- [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

@@ -4,6 +4,8 @@
 
 **类型**: `class`
 
+**头文件**: `XCEngine/Threading/ReadWriteLock.h`
+
 **描述**: 读写锁实现，支持多个并发读取或单一写入，提高读多写少场景的并发性能。
 
 ## 概述
@@ -16,15 +18,15 @@
 
 | 方法 | 描述 |
 |------|------|
-| `void ReadLock()` | 获取读锁（可重入，支持多个并发读者） |
-| `void ReadUnlock()` | 释放读锁 |
+| [`ReadLock`](readlock.md) | 获取读锁（可重入，支持多个并发读者） |
+| [`ReadUnlock`](readunlock.md) | 释放读锁 |
 
 ### 写锁
 
 | 方法 | 描述 |
 |------|------|
-| `void WriteLock()` | 获取写锁（独占，阻塞所有读者和写者） |
-| `void WriteUnlock()` | 释放写锁 |
+| [`WriteLock`](writelock.md) | 获取写锁（独占，阻塞所有读者和写者） |
+| [`WriteUnlock`](writeunlock.md) | 释放写锁 |
 
 ## 使用示例
 
@@ -33,10 +35,11 @@ Threading::ReadWriteLock rwLock;
 Containers::HashMap<String, int> sharedMap;
 
 // 读操作（多个线程可同时读）
-void ReadData(const String& key) {
+int* ReadData(const String& key) {
     rwLock.ReadLock();
     int* value = sharedMap.Find(key);
     rwLock.ReadUnlock();
+    return value;
 }
 
 // 写操作（独占）
@@ -49,5 +52,6 @@ void WriteData(const String& key, int value) {
 
 ## 相关文档
 
-- [Mutex](./threading-mutex.md) - 互斥锁
-- [SpinLock](./threading-spinlock.md) - 自旋锁
+- [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

@@ -4,6 +4,8 @@
 
 **类型**: `class`
 
+**头文件**: `XCEngine/Threading/SpinLock.h`
+
 **描述**: 自旋锁封装类，使用原子操作实现，适用于保护极短的临界区。
 
 ## 概述
@@ -14,9 +16,9 @@
 
 | 方法 | 描述 |
 |------|------|
-| `void Lock()` | 获取锁（忙等待） |
-| `void Unlock()` | 释放锁 |
-| `bool TryLock()` | 尝试获取锁（非阻塞） |
+| [`Lock`](lock.md) | 获取锁（忙等待） |
+| [`Unlock`](unlock.md) | 释放锁 |
+| [`TryLock`](trylock.md) | 尝试获取锁（非阻塞） |
 
 ## 使用示例
 
@@ -27,7 +29,7 @@ int counter = 0;
 // 保护极短的临界区
 void FastIncrement() {
     spinLock.Lock();
-    ++counter;  // 单一操作，无需切换到内核
+    ++counter;
     spinLock.Unlock();
 }
 
@@ -42,5 +44,6 @@ void SafeIncrement() {
 
 ## 相关文档
 
-- [Mutex](./threading-mutex.md) - 互斥锁
-- [ReadWriteLock](./threading-readwritelock.md) - 读写锁
+- [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(1)
+
+**注意：**
+- 已完成的任务不受影响。
+- 正在执行的任务继续执行直到完成。
+- 调用后所有 Wait/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);
+}
+
+group->Wait();
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览

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

@@ -0,0 +1,39 @@
+# TaskGroup::GetProgress
+
+```cpp
+float GetProgress() const
+```
+
+获取任务组的完成进度。
+
+**参数：** 无
+
+**返回：** `float` - 进度值，范围 0.0f ~ 1.0f
+
+**复杂度：** O(1)
+
+**示例：**
+
+```cpp
+TaskGroup* group = TaskSystem::Get().CreateTaskGroup();
+
+for (int i = 0; i < 1000; ++i) {
+    group->AddTask([i]() { ProcessItem(i); });
+}
+
+// 显示进度
+while (!group->IsComplete()) {
+    float progress = group->GetProgress();
+    printf("\rLoading: [%-50s] %.1f%%", 
+        std::string(50, '=').substr(0, (int)(progress * 50)).c_str(),
+        progress * 100.0f);
+    fflush(stdout);
+    Thread::Sleep(100);
+}
+printf("\n");
+```
+
+## 相关文档
+
+- [TaskGroup 总览](task-group.md) - 返回类总览
+- [IsComplete](iscomplete.md) - 检查是否完成

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

@@ -0,0 +1,34 @@
+# TaskGroup::IsComplete
+
+```cpp
+bool IsComplete() const
+```
+
+检查任务组中所有任务是否已完成。
+
+**参数：** 无
+
+**返回：** `bool` - 所有任务完成返回 true，否则返回 false
+
+**复杂度：** O(1)
+
+**示例：**
+
+```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

@@ -4,6 +4,8 @@
 
 **类型**: `class`
 
+**头文件**: `XCEngine/Threading/TaskGroup.h`
+
 **描述**: 任务组管理类，用于组织多个任务并支持批量等待、进度跟踪和依赖管理。
 
 ## 概述
@@ -23,30 +25,30 @@
 
 | 方法 | 描述 |
 |------|------|
-| `uint64_t AddTask(std::unique_ptr<ITask> task)` | 添加任务对象 |
-| `uint64_t AddTask(Callback&& func, TaskPriority priority = TaskPriority::Normal)` | 添加 lambda 任务 |
+| [`AddTask(unique_ptr)`](addtask.md) | 添加任务对象 |
+| [`AddTask(callback)`](addtask.md) | 添加 lambda 任务 |
 
 ### 依赖管理
 
 | 方法 | 描述 |
 |------|------|
-| `void AddDependency(uint64_t taskId, uint64_t dependsOn)` | 添加任务依赖关系 |
+| [`AddDependency`](adddependency.md) | 添加任务依赖关系 |
 
 ### 等待
 
 | 方法 | 描述 |
 |------|------|
-| `void Wait()` | 阻塞等待所有任务完成 |
-| `bool WaitFor(std::chrono::milliseconds timeout)` | 超时等待 |
+| [`Wait`](wait.md) | 阻塞等待所有任务完成 |
+| [`WaitFor`](waitfor.md) | 超时等待 |
 
 ### 回调和状态
 
 | 方法 | 描述 |
 |------|------|
-| `void SetCompleteCallback(Callback&& callback)` | 设置完成回调 |
-| `bool IsComplete() const` | 检查所有任务是否完成 |
-| `float GetProgress() const` | 获取完成进度（0.0f ~ 1.0f） |
-| `void Cancel()` | 取消所有任务 |
+| [`SetCompleteCallback`](setcompletecallback.md) | 设置完成回调 |
+| [`IsComplete`](iscomplete.md) | 检查所有任务是否完成 |
+| [`GetProgress`](getprogress.md) | 获取完成进度（0.0f ~ 1.0f） |
+| [`Cancel`](cancel.md) | 取消所有任务 |
 
 ## 使用示例
 
@@ -69,18 +71,12 @@ group->SetCompleteCallback([]() {
 // 等待完成
 group->Wait();
 
-// 或者超时等待
-if (group->WaitFor(std::chrono::seconds(5))) {
-    printf("Completed within 5 seconds\n");
-} else {
-    printf("Timeout, some tasks did not complete\n");
-}
-
 // 销毁
 TaskSystem::Get().DestroyTaskGroup(group);
 ```
 
 ## 相关文档
 
-- [ITask](./threading-task.md) - 任务基类
-- [TaskSystem](./threading-task-system.md) - 任务系统
+- [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,38 @@
+# TaskGroup::Wait
+
+```cpp
+void Wait()
+```
+
+阻塞当前线程，等待任务组中所有任务完成。
+
+**参数：** 无
+
+**返回：** 无
+
+**复杂度：** O(n)，n 为任务数量
+
+**注意：** 如果任务组已被取消，此方法将立即返回。
+
+**示例：**
+
+```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");
+group->Wait();
+printf("All tasks 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

@@ -4,6 +4,8 @@
 
 **类型**: `class` (singleton)
 
+**头文件**: `XCEngine/Threading/TaskSystem.h`
+
 **描述**: 并行任务调度系统单例，提供工作窃取式任务队列和并行 for 循环。
 
 ## 概述
@@ -14,7 +16,7 @@
 
 | 方法 | 描述 |
 |------|------|
-| `static TaskSystem& Get()` | 获取单例实例 |
+| [`Get`](get.md) | 获取单例实例 |
 
 ## 公共方法
 
@@ -22,47 +24,47 @@
 
 | 方法 | 描述 |
 |------|------|
-| `void Initialize(const TaskSystemConfig& config)` | 初始化任务系统 |
-| `void Shutdown()` | 关闭任务系统 |
+| [`Initialize`](initialize.md) | 初始化任务系统 |
+| [`Shutdown`](shutdown.md) | 关闭任务系统 |
 
 ### 任务提交
 
 | 方法 | 描述 |
 |------|------|
-| `uint64_t Submit(std::unique_ptr<ITask> task)` | 提交任务对象 |
-| `uint64_t Submit(std::function<void()>&& func, TaskPriority priority = TaskPriority::Normal)` | 提交 lambda 任务 |
+| [`Submit(unique_ptr)`](submit.md) | 提交任务对象 |
+| [`Submit(callback)`](submit.md) | 提交 lambda 任务 |
 
 ### 任务组
 
 | 方法 | 描述 |
 |------|------|
-| `TaskGroup* CreateTaskGroup()` | 创建任务组 |
-| `void DestroyTaskGroup(TaskGroup* group)` | 销毁任务组 |
+| [`CreateTaskGroup`](createtaskgroup.md) | 创建任务组 |
+| [`DestroyTaskGroup`](destroytaskgroup.md) | 销毁任务组 |
 
 ### 等待
 
 | 方法 | 描述 |
 |------|------|
-| `void Wait(uint64_t taskId)` | 等待指定任务完成 |
+| [`Wait`](wait.md) | 等待指定任务完成 |
 
 ### 信息
 
 | 方法 | 描述 |
 |------|------|
-| `uint32_t GetWorkerThreadCount() const` | 获取工作线程数量 |
+| [`GetWorkerThreadCount`](getworkerthreadcount.md) | 获取工作线程数量 |
 
 ### 并行 for
 
 | 方法 | 描述 |
 |------|------|
-| `template<typename Func> void ParallelFor(int32_t start, int32_t end, Func&& func)` | 并行执行 for 循环 |
+| [`ParallelFor`](parallelfor.md) | 并行执行 for 循环 |
 
 ### 主线程
 
 | 方法 | 描述 |
 |------|------|
-| `void RunOnMainThread(std::function<void()>&& func)` | 将任务提交到主线程执行 |
-| `void Update()` | 在主线程中处理主线程队列 |
+| [`RunOnMainThread`](runonmainthread.md) | 将任务提交到主线程执行 |
+| [`Update`](update.md) | 在主线程中处理主线程队列 |
 
 ## 使用示例
 
@@ -83,7 +85,6 @@ TaskSystem::Get().Submit([]() {
 
 // 并行 for
 TaskSystem::Get().ParallelFor(0, 1000, [](int32_t i) {
-    // 每个 i 独立处理
     process(i);
 });
 
@@ -95,7 +96,6 @@ TaskSystem::Get().RunOnMainThread([]() {
 // 主循环中调用 Update
 while (running) {
     TaskSystem::Get().Update();  // 处理主线程任务
-    // 其他渲染...
 }
 
 // 关闭
@@ -104,7 +104,8 @@ TaskSystem::Get().Shutdown();
 
 ## 相关文档
 
-- [ITask](./threading-task.md) - 任务基类
-- [LambdaTask](./threading-lambdatask.md) - Lambda 任务
-- [TaskGroup](./threading-task-group.md) - 任务组
-- [TaskSystemConfig](./threading-tasksystemconfig.md) - 配置
+- [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（空实现）
+
+**建议：** 建议使用 `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

@@ -1,8 +1,10 @@
-# ITask / Task
+# ITask
 
 **命名空间**: `XCEngine::Threading`
 
-**类型**: `class` (abstract) / `enum`
+**类型**: `class` (abstract)
+
+**头文件**: `XCEngine/Threading/Task.h`
 
 **描述**: 任务基类抽象接口和任务状态/优先级枚举定义。
 
@@ -41,27 +43,27 @@
 
 | 方法 | 描述 |
 |------|------|
-| `virtual void Execute() = 0` | 任务执行逻辑（纯虚） |
-| `virtual void OnComplete() {}` | 任务完成回调（可重写） |
-| `virtual void OnCancel() {}` | 任务取消回调（可重写） |
+| [`Execute`](execute.md) | 任务执行逻辑（纯虚） |
+| [`OnComplete`](oncomplete.md) | 任务完成回调（可重写） |
+| [`OnCancel`](oncancel.md) | 任务取消回调（可重写） |
 
 ### 属性
 
 | 方法 | 描述 |
 |------|------|
-| `TaskPriority GetPriority() const` | 获取优先级 |
-| `TaskStatus GetStatus() const` | 获取状态 |
-| `uint64_t GetId() const` | 获取任务 ID |
-| `void SetId(uint64_t id)` | 设置任务 ID |
-| `void SetPriority(TaskPriority priority)` | 设置优先级 |
-| `void SetStatus(TaskStatus status)` | 设置状态 |
+| [`GetPriority`](getpriority.md) | 获取优先级 |
+| [`GetStatus`](getstatus.md) | 获取状态 |
+| [`GetId`](getid.md) | 获取任务 ID |
+| [`SetId`](setid.md) | 设置任务 ID |
+| [`SetPriority`](setpriority.md) | 设置优先级 |
+| [`SetStatus`](setstatus.md) | 设置状态 |
 
 ### 引用计数
 
 | 方法 | 描述 |
 |------|------|
-| `void AddRef()` | 增加引用计数 |
-| `void Release()` | 减少引用计数（自动 delete 引用归零时） |
+| [`AddRef`](addref.md) | 增加引用计数 |
+| [`Release`](release.md) | 减少引用计数（引用归零时自动 delete） |
 
 ## 使用示例
 
@@ -71,19 +73,17 @@ 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));
@@ -91,6 +91,7 @@ TaskSystem::Get().Submit(std::unique_ptr<ITask>(task));
 
 ## 相关文档
 
-- [LambdaTask](./threading-lambdatask.md) - Lambda 任务封装
-- [TaskGroup](./threading-task-group.md) - 任务组
-- [TaskSystem](./threading-task-system.md) - 任务系统
+- [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,27 @@
+# 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,22 @@
+# 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,23 @@
+# 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,26 @@
+# TaskSystemConfig::threadStackSize
+
+```cpp
+uint32_t threadStackSize = 0
+```
+
+工作线程的栈大小（字节）。值为 0 时使用系统默认值。
+
+**类型：** `uint32_t`
+
+**默认值：** `0`（使用系统默认）
+
+**示例：**
+
+```cpp
+TaskSystemConfig config;
+config.workerThreadCount = 4;
+config.threadStackSize = 1024 * 1024; // 1MB 栈大小
+
+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 <XCEngine/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

@@ -31,24 +31,24 @@
 
 | 方法 | 描述 |
 |------|------|
-| `template<typename Func> void Start(Func&& func, const Containers::String& name = "Thread")` | 启动线程，执行传入的函数 |
-| `void Join()` | 等待线程结束 |
-| `void Detach()` | 分离线程，使其独立运行 |
+| [`Start`](start.md) | 启动线程，执行传入的函数 |
+| [`Join`](join.md) | 等待线程结束 |
+| [`Detach`](detach.md) | 分离线程，使其独立运行 |
 
 ### 属性访问
 
 | 方法 | 描述 |
 |------|------|
-| `Id GetId() const` | 获取线程 ID |
-| `const Containers::String& GetName() const` | 获取线程名称 |
+| [`GetId`](getid.md) | 获取线程 ID |
+| [`GetName`](getname.md) | 获取线程名称 |
 
 ### 静态方法
 
 | 方法 | 描述 |
 |------|------|
-| `static Id GetCurrentId()` | 获取当前线程 ID |
-| `static void Sleep(uint32_t milliseconds)` | 线程休眠指定毫秒数 |
-| `static void Yield()` | 让出当前线程的时间片 |
+| [`GetCurrentId`](getcurrentid.md) | 获取当前线程 ID |
+| [`Sleep`](sleep.md) | 线程休眠指定毫秒数 |
+| [`Yield`](yield.md) | 让出当前线程的时间片 |
 
 ## 使用示例
 
@@ -58,7 +58,6 @@
 // 创建并启动线程
 Thread thread;
 thread.Start([]() {
-    // 线程工作
     printf("Worker thread running\n");
 }, "WorkerThread");
 
@@ -73,5 +72,6 @@ auto currentId = Thread::GetCurrentId();
 
 ## 相关文档
 
-- [Mutex](./threading-mutex.md) - 互斥锁
-- [TaskSystem](./threading-task-system.md) - 任务调度系统
+- [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-tasksystemconfig.md

@@ -1,33 +0,0 @@
-# TaskSystemConfig
-
-**命名空间**: `XCEngine::Threading`
-
-**类型**: `struct`
-
-**描述**: 任务系统配置结构体。
-
-## 结构体成员
-
-| 成员 | 类型 | 描述 | 默认值 |
-|------|------|------|--------|
-| `workerThreadCount` | `uint32_t` | 工作线程数量（0=自动检测） | 0 |
-| `enableTaskProfiling` | `bool` | 启用任务性能分析 | true |
-| `stealTasks` | `bool` | 启用工作窃取 | true |
-| `maxTaskQueueSize` | `uint32_t` | 最大任务队列大小 | 1024 |
-| `threadStackSize` | `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](./threading-task-system.md) - 任务系统

docs/api/threading/threading.md

@@ -16,25 +16,25 @@ Threading 模块提供了一套完整的多线程编程工具，包括线程封
 
 | 组件 | 文件 | 描述 |
 |------|------|------|
-| [Mutex](./threading-mutex.md) | `Mutex.h` | 互斥锁 |
-| [SpinLock](./threading-spinlock.md) | `SpinLock.h` | 自旋锁 |
-| [ReadWriteLock](./threading-readwritelock.md) | `ReadWriteLock.h` | 读写锁 |
+| [Mutex](mutex/mutex.md) | `Mutex.h` | 互斥锁 |
+| [SpinLock](spinlock/spinlock.md) | `SpinLock.h` | 自旋锁 |
+| [ReadWriteLock](readwritelock/readwritelock.md) | `ReadWriteLock.h` | 读写锁 |
 
 ### 线程
 
 | 组件 | 文件 | 描述 |
 |------|------|------|
-| [Thread](./threading-thread.md) | `Thread.h` | 线程封装类 |
+| [Thread](thread/thread.md) | `Thread.h` | 线程封装类 |
 
 ### 任务系统
 
 | 组件 | 文件 | 描述 |
 |------|------|------|
-| [ITask](./threading-task.md) | `Task.h` | 任务基类 |
-| [LambdaTask](./threading-lambdatask.md) | `LambdaTask.h` | Lambda 任务封装模板 |
-| [TaskGroup](./threading-task-group.md) | `TaskGroup.h` | 任务组 |
-| [TaskSystem](./threading-task-system.md) | `TaskSystem.h` | 并行任务调度系统 |
-| [TaskSystemConfig](./threading-tasksystemconfig.md) | `TaskSystemConfig.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` | 任务系统配置 |
 
 ## 同步原语对比
 
@@ -71,4 +71,4 @@ TaskSystem::Get().DestroyTaskGroup(group);
 
 ## 相关文档
 
-- [Memory 模块](../memory/memory-overview.md) - 内存分配器
+- [Memory 模块](../memory/memory.md) - 内存分配器