1. 修改第三章单例的示例，添加 inline 关键字

2. 修正”C++20信号量“的部分描述
3. 修改“C++20 闩与屏障”一节内容，修改完成了 `std::latch`，更新部分 `std::barrier` #12

Author: Mq-b

Diff for: md/03共享数据.md

@@ -725,13 +725,13 @@ void process_data(){
 
    ```cpp
    class my_class;
-   my_class& get_my_class_instance(){
+   inline my_class& get_my_class_instance(){
        static my_class instance;  // 线程安全的初始化过程 初始化严格发生一次
        return instance;
    }
    ```
 
-   多线程可以安全的调用 `get_my_class_instance` 函数，不用为数据竞争而担心。此方式也在单例中多见，是简单合理的做法。
+   即使多个线程同时访问 `get_my_class_instance` 函数，也只有一个线程会执行 instance 的初始化，其它线程会等待初始化完成。这种实现方式是线程安全的，不用担心数据竞争。此方式也在单例中多见，被称作“Meyers Singleton”单例，是简单合理的做法。
 
 ---
 

Diff for: md/04同步操作.md

@@ -1219,58 +1219,146 @@ int main() {
 
 这段代码很简单，以至于我们可以在这里来再说一条概念：
 
-- `counting_semaphore` 是一个轻量同步原语，能控制对共享资源的访问。不同于 [std::mutex](https://zh.cppreference.com/w/cpp/thread/mutex)，`counting_semaphore` **允许同一资源进行多个并发的访问**，至少允许 `LeastMaxValue` 个同时的访问者。
+- `counting_semaphore` 是一个轻量同步原语，能控制对共享资源的访问。不同于 [std::mutex](https://zh.cppreference.com/w/cpp/thread/mutex)，`counting_semaphore` **允许同一资源进行多个并发的访问**，***至少**允许 `LeastMaxValue` 个同时访问者*[^5]。
 - `binary_semaphore` 是 `std::counting_semaphore` 的特化的别名，其 `LeastMaxValue` 为 1。
 
-`LeastMaxValue` 是我们设置的非类型模板参数，意思是信号量维护的计数最大值。我们这段代码设置的是 `3`，也就是允许 3 个同时访问者。事实上我们的代码就是这样做的。
+`LeastMaxValue` 是我们设置的非类型模板参数，意思是信号量维护的**计数最大值**。我们这段代码设置的是 `3`，也就是允许 3 个同时访问者。
+
+> 虽然说是说有 LeastMaxValue 可能不是最大，但是我们通常不用在意这个事情，[MSVC STL 的实现](https://github.com/microsoft/STL/blob/697653d/stl/inc/semaphore#L63-L65)中 max 函数就是直接返回 `LeastMaxValue`，将它视为信号量维护的计数最大值即可。
 
 牢记信号量的基本的概念不变，计数的值不能小于 `0`，如果当前信号量的计数值为 `0`，那么执行“***等待***”（acquire）操作的线程将会**一直阻塞**。明白这点，那么就都不存在问题。
 
 通过这种方式，可以有效控制 Web 服务器处理并发请求的数量，防止服务器过载。
 
 [^4]:注：**如果信号量只有二进制的 0 或 1，称为二进制信号量（binary semaphore）**，这就是这个类型名字的由来。
 
-## C++20  闩与屏障
+[^5]:注：如其名所示，LeastMaxValue 是**最小 的最大值**，而**非实际 最大值**。静态成员函数 [`max()`](https://zh.cppreference.com/w/cpp/thread/counting_semaphore/max)可能产生大于 LeastMaxValue 的值。
+
+## C++20 闩与屏障
 
 闩 (latch) 与屏障 (barrier) 是线程协调机制，允许任何数量的线程阻塞**直至期待数量的线程到达**。闩不能重复使用，而屏障则可以。
 
 - **`std::latch`：单次使用的线程屏障**
 - **`std::barrier`：可复用的线程屏障**
 
-它们定义在标头 **`<latch>`**。
+它们定义在标头 **`<latch>`** 与  **`<barrier>`**。
 
 与信号量类似，屏障也是一种古老而广泛应用的同步机制。许多系统 API 提供了对屏障机制的支持，例如 POSIX 和 Win32。此外，[OpenMP](https://learn.microsoft.com/zh-cn/cpp/parallel/openmp/2-directives?view=msvc-170#263-barrier-directive) 也提供了屏障机制来支持多线程编程。
 
 ### `std::latch`
 
-“闩”，这个字其实个人觉得是不常见，“**门闩**” 是指们背后用来关门的棍子。好了好了，不用在意，在 C++ 中就是先前说的：*单次使用的线程屏障*。
+“闩”，这个字其实个人觉得是不常见，“**门闩**” 是指门背后用来关门的棍子。好了好了，不用在意，在 C++ 中就是先前说的：*单次使用的线程屏障*。
 
-`latch` 类维护着一个 [`std::ptrdiff_t`](https://zh.cppreference.com/w/cpp/types/ptrdiff_t) 类型的计数[^5]，且只能**减少**计数，**无法增加计数**。在创建对象的时候初始化计数器的值。线程可以阻塞，直到 latch 对象的计数减少到零。由于无法增加计数，这使得 `latch` 成为一种**单次使用的屏障**。
+`latch` 类维护着一个 [`std::ptrdiff_t`](https://zh.cppreference.com/w/cpp/types/ptrdiff_t) 类型的计数[^6]，且只能**减少**计数，**无法增加计数**。在创建对象的时候初始化计数器的值。线程可以阻塞，直到 latch 对象的计数减少到零。由于无法增加计数，这使得 `latch` 成为一种**单次使用的屏障**。
 
 ```cpp
-std::latch work_done{ 3 };
+std::latch work_start{ 3 };
 
 void work(){
     std::cout << "等待其它线程执行\n";
-    work_done.wait(); // 等待计数为 0
+    work_start.wait(); // 等待计数为 0
     std::cout << "任务开始执行\n";
 }
+
 int main(){
     std::jthread thread{ work };
     std::this_thread::sleep_for(3s);
-    work_done.count_down();  // 默认值是 1
-    work_done.count_down(2); // 传递参数 减少计数 2
+    std::cout << "休眠结束\n";
+    work_start.count_down();  // 默认值是 1 减少计数 1
+    work_start.count_down(2); // 传递参数 2 减少计数 2
+}
+```
+
+[**运行结果**](https://godbolt.org/z/sEhMeraYs)：
+
+```txt
+等待其它线程执行
+休眠结束
+任务开始执行
+```
+
+在这个例子中，通过调用 `wait` 函数阻塞子线程，直到主线程调用 `count_down` 函数原子地将计数减至 `0`，从而解除阻塞。这个例子清楚地展示了 `latch` 的使用，其逻辑比信号量更简单。
+
+---
+
+由于 `latch` 的计数不可增加，它的使用通常非常简单，可以用来划分任务执行的工作区间。例如：
+
+```cpp
+std::latch latch{ 10 };
+
+void f(int id) {
+    //todo.. 脑补任务
+    std::this_thread::sleep_for(1s);
+    std::cout << std::format("线程 {} 执行完任务，开始等待其它线程执行到此处\n", id);
+    latch.arrive_and_wait();
+    std::cout << std::format("线程 {} 彻底退出函数\n", id);
+}
+
+int main() {
+    std::vector<std::jthread> threads;
+    for (int i = 0; i < 10; ++i) {
+        threads.emplace_back(f,i);
+    }
 }
 ```
 
-> [运行](https://godbolt.org/z/Trhh9jdbf)测试。
+> [运行](https://godbolt.org/z/KKjdWWKdq)测试。
+
+[`arrive_and_wait`](https://zh.cppreference.com/w/cpp/thread/latch/arrive_and_wait) 函数等价于：`count_down(n); wait();`。也就是减少计数 + 等待。这意味着
 
-通过调用 `wait` 函数阻塞子线程，直到主线程调用 `count_down` 函数原子地将计数减至 `0` ，得以解除阻塞。相信这个例子就能很清楚的展示 `latch` 的使用，它的逻辑比信号量还要简单。
+必须等待所有线程执行到 `latch.arrive_and_wait();` 将 latch 的计数减少至 `0` 才能继续往下执行。这个示例非常直观地展示了如何使用 `latch` 来划分任务执行的工作区间。
 
-[^5]: 注：通常的[实现](https://github.com/microsoft/STL/blob/939513b/stl/inc/latch#L88)是直接保有一个 `std::atomic<std::ptrdiff_t>` 私有数据成员，以保证计数修改的原子性。原子类型在我们第五章的内容会详细展开。
+由于 `latch` 的功能受限，通常用于简单直接的需求，不少情况很多同步设施都能完成你的需求，在这个时候请考虑**使用尽可能功能最少的那一个**。
+
+- 使用功能尽可能少的设施有助于开发者阅读代码理解含义。如果使用的是一个功能丰富的设施，可能就无法直接猜测其意图。
+
+[^6]: 注：通常的[实现](https://github.com/microsoft/STL/blob/939513b/stl/inc/latch#L88)是直接保有一个 `std::atomic<std::ptrdiff_t>` 私有数据成员，以保证计数修改的原子性。原子类型在我们第五章的内容会详细展开。
 
 ### `std::barrier`
 
+上节我们学习了 `std::latch` ，本节内容也不会对你构成难度。
+
+[`std::barrier`](https://zh.cppreference.com/w/cpp/thread/barrier) 和 `std::latch` 最大的不同是，前者可以在阶段完成之后将计数重置为构造时传递的值，而后者只能减少计数。我们用一个非常简单直观的示例为你展示：
+
+```cpp
+std::barrier barrier{ 10,
+    [n = 1]()mutable noexcept {std::cout << "\t第" << n++ << "轮结束\n"; }
+};
+
+void f(int start, int end){
+    for (int i = start; i <= end; ++i) {
+        std::osyncstream{ std::cout } << i << ' '; 
+        barrier.arrive_and_wait(); // 减少计数并等待 解除阻塞时就重置计数并调用函数对象
+        
+        std::this_thread::sleep_for(300ms);
+    }
+}
+
+int main(){
+    std::vector<std::jthread> threads;
+    for (int i = 0; i < 10; ++i) {
+        threads.emplace_back(f, i * 10 + 1, (i + 1) * 10);
+    }
+}
+```
+
+**可能的[运行结果](https://godbolt.org/z/9Tnsz537e)**：
+
+```txt
+1 21 11 31 41 51 61 71 81 91    第1轮结束
+12 2 22 32 42 52 62 72 92 82    第2轮结束
+13 63 73 33 23 53 83 93 43 3    第3轮结束
+14 44 24 34 94 74 64 4 84 54    第4轮结束
+5 95 15 45 75 25 55 65 35 85    第5轮结束
+6 46 16 26 56 96 86 66 76 36    第6轮结束
+47 17 57 97 87 67 77 7 27 37    第7轮结束
+38 8 28 78 68 88 98 58 18 48    第8轮结束
+9 39 29 69 89 99 59 19 79 49    第9轮结束
+30 40 70 10 90 50 60 20 80 100  第10轮结束
+```
+
+注意输出的规律，第一轮每个数字最后一位都是 `1`，第二轮每个数字最后一位都是 `2`……以此类推，因为我们分配给每个线程的输出任务就是如此，然后利用了屏障一轮一轮地打印。
+
 ## 总结
 
 在并发编程中，同步操作对于并发编程至关重要。如果没有同步，线程基本上就是独立的，因其任务之间的相关性，才可作为一个整体执行（比如第二章的并行求和）。本章讨论了多种用于同步操作的工具，包括条件变量、future、promise、package_task、信号量。同时，详细介绍了 C++ 时间库的知识，以使用并发支持库中的“限时等待”。还使用 CMake + Qt 构建了一个带有 UI 界面的示例，展示异步多线程的**必要性**。