调整线程池的内容描述，修改提供的测试链接，调整顺序。修改测试的 demo，为线程池增加一些描述解释

Author: Mq-b

md/详细分析/04线程池.md

@@ -104,14 +104,14 @@ int main() {
     boost::asio::thread_pool pool{4}; // 创建一个包含 4 个线程的线程池
 
     for (int i = 0; i < 10; ++i) {
-        boost::asio::post(pool, [i]() { print_task(i); });
+        boost::asio::post(pool, [i] { print_task(i); });
     }
 
     pool.join(); // 等待所有任务执行完成
 }
 ```
 
-> [运行](https://godbolt.org/z/h5G5hTT4a)测试。
+> [运行](https://godbolt.org/z/Pa3z1oYej)测试。
 
 - 创建线程池时，指定线程数量，线程池会创建对应数量的线程。
 
@@ -297,7 +297,7 @@ class ThreadPool {
    - 用于线程间的同步，允许线程等待特定条件（如新任务加入队列）并在条件满足时唤醒线程。
 
 3. **`std::atomic<bool> stop_`**
-   - 用于指示线程池是否停止接收新任务，并安全地通知所有工作线程退出。
+   - 指示线程池是否停止。
 
 4. **`std::atomic<std::size_t> num_threads_`**
    - 表示线程池中的线程数量。
@@ -309,7 +309,22 @@ class ThreadPool {
 
    - 线程容器，存储管理线程对象，每个线程从任务队列中获取任务并执行。
 
-那么再直接提供构造函数以及添加任务到线程池的接口，然后内部再进行一点小小的操作，也就完成了：
+**标头依赖**：
+
+```cpp
+#include <iostream>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <future>
+#include <atomic>
+#include <queue>
+#include <vector>
+#include <syncstream>
+#include <functional>
+```
+
+提供构造析构函数，以及一些外部接口：`submit()`、`start()`、`stop()`、`join()`，也就完成了：
 
 ```cpp
 inline std::size_t default_thread_pool_size()noexcept {
@@ -330,7 +345,7 @@ public:
         start();
     }
 
-    ~ThreadPool() {
+    ~ThreadPool(){
         stop();
         join();
     }
@@ -340,7 +355,7 @@ public:
         cv_.notify_all();
     }
 
-    void join() {
+    void join(){
         for (auto& thread : pool_) {
             if (thread.joinable()) {
                 thread.join();
@@ -368,8 +383,8 @@ public:
         return ret;
     }
 
-    void start() {
-        for (std::size_t i = 0; i < num_threads_; ++i) {
+    void start(){
+        for (std::size_t i = 0; i < num_threads_; ++i){
             pool_.emplace_back([this] {
                 while (!stop_) {
                     Task task;
@@ -383,7 +398,7 @@ public:
                     }
                     task();
                 }
-                });
+            });
         }
     }
 
@@ -397,74 +412,85 @@ private:
 };
 ```
 
-**标头依赖**：
-
-```cpp
-#include <iostream>
-#include <thread>
-#include <mutex>
-#include <condition_variable>
-#include <future>
-#include <atomic>
-#include <queue>
-#include <vector>
-#include <syncstream>
-#include <functional>
-```
-
 **测试 demo**：
 
 ```cpp
-void print_task(int n) {
+int print_task(int n) {
     std::osyncstream{ std::cout } << "Task " << n << " is running." << std::endl;
+    return n;
 }
-void print_task2(int n) {
+int print_task2(int n) {
     std::osyncstream{ std::cout } << "🐢🐢🐢 " << n << " 🐉🐉🐉" << std::endl;
+    return n;
 }
 
 int main() {
     ThreadPool pool{ 4 }; // 创建一个有 4 个线程的线程池
+    std::vector<std::future<int>> futures; // future 集合，获取返回值
 
     for (int i = 0; i < 10; ++i) {
-        pool.submit(print_task, i);
+        futures.emplace_back(pool.submit(print_task, i));
     }
-    pool.join(); // 确保执行完所有任务
+    pool.join();
 
     std::puts("---------------------");
 
-    pool.start(); // 重新启动线程池
+    pool.start();
 
     for (int i = 0; i < 10; ++i) {
-        pool.submit(print_task2, i);
+        futures.emplace_back(pool.submit(print_task2, i));
     }
-    pool.join(); // 确保执行完所有任务
+    pool.join();
+
+    int sum = 0;
+    for(auto& future : futures){
+        sum += future.get();
+    }
+    std::cout << "sum: " << sum << '\n';
 } // 析构自动 stop() join()
 ```
 
-**可能的[运行结果](https://godbolt.org/z/rM6vz1s9v)**：
+**可能的[运行结果](https://godbolt.org/z/YT4ahh1Wz)**：
 
 ```shell
-Task 1 is running.
-Task 2 is running.
 Task 0 is running.
-Task 3 is running.
 Task 4 is running.
 Task 5 is running.
 Task 6 is running.
 Task 7 is running.
 Task 8 is running.
 Task 9 is running.
+Task 2 is running.
+Task 3 is running.
+Task 1 is running.
 ---------------------
 🐢🐢🐢 0 🐉🐉🐉
-🐢🐢🐢 2 🐉🐉🐉
 🐢🐢🐢 1 🐉🐉🐉
+🐢🐢🐢 2 🐉🐉🐉
 🐢🐢🐢 5 🐉🐉🐉
-🐢🐢🐢 7 🐉🐉🐉
-🐢🐢🐢 3 🐉🐉🐉
 🐢🐢🐢 4 🐉🐉🐉
+🐢🐢🐢 3 🐉🐉🐉
 🐢🐢🐢 6 🐉🐉🐉
+🐢🐢🐢 7 🐉🐉🐉
 🐢🐢🐢 8 🐉🐉🐉
 🐢🐢🐢 9 🐉🐉🐉
+sum: 90
 ```
 
-如果不自己显式调用 `join()` ，而是等待线程池析构调用，那么效果如同 `asio::thread_pool`，会先进行 `stop`，导致一些任务不执行。
+> 如果不自己显式调用 `join()` ，而是等待线程池对象调用析构函数，那么效果如同 `asio::thread_pool`，会先进行 `stop`，导致一些任务不执行。
+
+ **构造函数和析构函数：**
+
+- **构造函数**：初始化线程池并**启动线程**。
+
+- **析构函数**：停止线程池并等待所有线程结束。
+
+**外部接口：**
+
+- **`stop()`**：停止线程池，通知所有线程退出（不会等待所有任务执行完毕）。
+
+- **`join()`**：等待所有线程完成任务。
+
+- **`submit()`**：将任务提交到任务队列，并返回一个`std::future`对象用于获取任务结果。
+
+- **`start()`**：启动线程池，创建并启动指定数量的线程。