1. 修改第三章的“使用互斥量”中的用词与格式，增加脚注

2. 为第三章增加三级标题 `std::lock_guard`，且增加一小节 `try_lock`
3. 修改第三章“死锁”的一个字
4. 修改第三章“`new`、`delete` 是线程安全的吗？”这一节的格式
5. 为第四章增加一节内容 “等待事件或条件” 完成大部分

Author: Mq-b

md/03共享数据.md

@@ -73,11 +73,13 @@ std::thread t1{f}, t2{f}, t3{f}; // 未定义行为
 
 ## 使用互斥量
 
-互斥量（Mutex），又称为互斥锁， 是一种用来保护**临界区**的特殊对象，它可以处于锁定（locked） 状态， 也可以处于解锁（unlocked） 状态：
+互斥量（Mutex），又称为互斥锁，是一种用来保护**临界区**[^1]的特殊对象，它可以处于锁定（locked）状态，也可以处于解锁（unlocked）状态：
 
-1、如果互斥锁是锁定的， 通常说某个特定的线程正持有这个互斥锁
+1. 如果互斥锁是锁定的， 通常说某个特定的线程正持有这个互斥锁
 
-2、如果没有线程持有这个互斥锁，那么这个互斥锁就处于解锁状态
+2. 如果没有线程持有这个互斥量，那么这个互斥量就处于解锁状态
+
+[^1]: "***[临界区](https://zh.wikipedia.org/wiki/%E8%87%A8%E7%95%8C%E5%8D%80%E6%AE%B5)***"指的是一个访问共享资源的程序片段，而这些共享资源又无法同时被多个线程访问的特性。在临界区中，通常会使用同步机制，比如我们要讲的互斥量（Mutex）。
 
 ---
 
@@ -128,6 +130,8 @@ int main() {
 
 看一遍描述就可以了，简而言之，被 `lock()` 和 `unlock()` 包含在其中的代码是线程安全的，同一时间只有一个线程执行，不会被其它线程的执行所打断。
 
+### `std::lock_guard`
+
 不过一般不推荐这样显式的 `lock()` 与 `unlock()`，我们可以使用 C++11 标准库引入的“管理类” [`std::lock_guard`](https://zh.cppreference.com/w/cpp/thread/lock_guard)：
 
 ```cpp
@@ -257,6 +261,43 @@ std::scoped_lock lc{ m }; // std::scoped_lock<std::mutex>
 
 我们在后续管理多个互斥量，会详细了解这个类。
 
+### `try_lock`
+
+`try_lock` 是互斥量中的一种尝试上锁的方式。与常规的 `lock` 不同，`try_lock` 会尝试上锁，但如果锁已经被其他线程占用，则**不会阻塞当前线程，而是立即返回**。
+
+它的返回类型是 `bool` ，如果上锁成功就返回 `true`，失败就返回 `false`。
+
+这种方法在多线程编程中很有用，特别是在需要保护临界区的同时，又不想线程因为等待锁而阻塞的情况下。
+
+```cpp
+std::mutex mtx;
+
+void threadFunction(int id) {
+    // 尝试加锁
+    if (mtx.try_lock()) {
+        std::cout << "线程：" << id << " 获得锁" << std::endl;
+        // 临界区代码
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟临界区操作
+        mtx.unlock(); // 解锁
+        std::cout << "线程：" << id << " 释放锁" << std::endl;
+    } else {
+        std::cout << "线程：" << id << " 获取锁失败 处理步骤" << std::endl;
+    }
+}
+```
+
+如果有两个线程运行这段代码，必然有一个线程无法成功上锁，要走 else 的分支。
+
+```cpp
+std::thread t1(threadFunction, 1);
+std::thread t2(threadFunction, 2);
+
+t1.join();
+t2.join();
+```
+
+> [运行](https://godbolt.org/z/ajjxnPGMG)测试。
+
 ## 保护共享数据
 
 互斥量主要也就是为了保护共享数据，上一节的*使用互斥量*也已经为各位展示了一些。
@@ -310,7 +351,7 @@ void foo(){
 
 试想一下，有一个玩具，这个玩具有两个部分，必须同时拿到两部分才能玩。比如一个遥控汽车，需要遥控器和玩具车才能玩。有两个小孩，他们都想玩这个玩具。当其中一个小孩拿到了遥控器和玩具车时，就可以尽情玩耍。当另一个小孩也想玩，他就得等待另一个小孩玩完才行。再试想，遥控器和玩具车被放在两个不同的地方，并且两个小孩都想要玩，并且一个拿到了遥控器，另一个拿到了玩具车。问题就出现了，除非其中一个孩子决定让另一个先玩，他把自己的那个部分给另一个小孩。但如果他们都不愿意，那么这个遥控汽车就谁都没有办法玩。
 
-我们当然不在于小孩抢玩具，我们要聊的是线程对锁的竞争：*两个线程需要对它们所有的互斥量做一些操作，其中每个线程都有一个互斥量，且等待另一个线程的互斥量解锁。因为它们都在等待对方释放互斥量，没有线程工作。* 这种情况就是死锁。
+我们当然不在乎小孩抢玩具，我们要聊的是线程对锁的竞争：*两个线程需要对它们所有的互斥量做一些操作，其中每个线程都有一个互斥量，且等待另一个线程的互斥量解锁。因为它们都在等待对方释放互斥量，没有线程工作。* 这种情况就是死锁。
 
 - **多个互斥量才可能遇到死锁问题**。
 
@@ -781,8 +822,8 @@ void recursiveFunction(int count) {
 
 如果你的标准达到 **C++11**，要求下列**函数**是线程安全的：
 
-- [**`new` 运算符**](https://zh.cppreference.com/w/cpp/memory/new/operator_new)和 [`delete` 运算符](https://zh.cppreference.com/w/cpp/memory/new/operator_delete)的**库**版本
-- 全局 **`new` 运算符**和 `delete` 运算符的用户替换版本
+- [`new` 运算符](https://zh.cppreference.com/w/cpp/memory/new/operator_new)和 [`delete` 运算符](https://zh.cppreference.com/w/cpp/memory/new/operator_delete)的**库**版本
+- 全局 `new` 运算符和 `delete` 运算符的用户替换版本
 - [std::calloc](https://zh.cppreference.com/w/cpp/memory/c/calloc)、[std::malloc](https://zh.cppreference.com/w/cpp/memory/c/malloc)、[std::realloc](https://zh.cppreference.com/w/cpp/memory/c/realloc)、[std::aligned_alloc](https://zh.cppreference.com/w/cpp/memory/c/aligned_alloc) (C++17 起)、[std::free](https://zh.cppreference.com/w/cpp/memory/c/free)
 
 所以以下函数在多线程运行是线程安全的：

md/04同步操作.md

@@ -9,3 +9,96 @@
 - `std::future` 等待异步任务
 
 - 在规定时间内等待
+
+本章将讨论如何使用条件变量等待事件，介绍 future，等标准库设施用作同步操作。
+
+## 等待事件或条件
+
+假设你正在一辆夜间运行的地铁上，那么你在正确的站点下车呢？
+
+1. 一直不休息，每一站都能知道，这样就不会错过你要下车的站点，但是这会很疲惫。
+
+2. 可以看一下时间，估算一下火车到达目的地的时间，然后设置一个稍早的闹钟，就休息。这个方法听起来还行，但是你可能被过早的叫醒，甚至估算错误，以及坐过站，又或者闹钟没电了，睡过站。
+
+3. 事实上最简单的方式是，到站的时候有人或者其它东西能将你叫醒（比如手机的地图，到达设置的位置就提醒）。
+
+这和线程有什么关系呢？其实第一种方法就是在说轮询。
+
+```cpp
+bool flag = false;
+std::mutex m;
+
+void wait_for_flag(){
+    std::unique_lock<std::mutex>lk{ m };
+    while (!flag){
+        lk.unlock();    // 1 解锁互斥量
+        lk.lock();      // 2 上锁互斥量
+    }
+}
+```
+
+第二种方法就是加个延时，这种实现进步了很多，减少浪费的执行时间，但很难确定正确的休眠时间。这会影响到程序的行为，在需要快速响应的程序中就意味着丢帧或错过了一个时间片。
+
+```cpp
+void wait_for_flag(){
+    std::unique_lock<std::mutex>lk{ m };
+    while (!flag){
+        lk.unlock();    // 1 解锁互斥量
+        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 2 休眠
+        lk.lock();      // 3 上锁互斥量
+    }
+}
+```
+
+第三种方式（也是最好的）实际上就是使用条件变量了。通过另一线程触发等待事件的机制是最基本的唤醒方式，这种机制就称为“条件变量”。
+
+C++ 标准库对条件变量有两套实现：[`std::condition_variable`](https://zh.cppreference.com/w/cpp/thread/condition_variable) 和 [`std::condition_variable_any`](https://zh.cppreference.com/w/cpp/thread/condition_variable_any)，这两个实现都包含在 [`<condition_variable>`](https://zh.cppreference.com/w/cpp/header/condition_variable) 头文件中。
+
+`condition_variable_any` 类是 `std::condition_variable` 的泛化。相对于只在 `std::unique_lock<std::mutex>` 上工作的 `std::condition_variable`，`condition_variable_any` 能在任何满足[*可基本锁定(BasicLockable)*](https://zh.cppreference.com/w/cpp/named_req/BasicLockable)要求的锁上工作，所以增加了 `_any` 后缀。显而易见，这种区分必然是 `any` 版**更加通用但是却又更多的性能开销**。所以通常**首选** `std::condition_variable`。有特殊需求，才会考虑 `std::condition_variable_any`。
+
+```cpp
+std::mutex mtx;
+std::condition_variable cv;
+bool arrived = false;
+
+void waitForArrival() {
+    std::unique_lock<std::mutex> lck(mtx);
+    cv.wait(lck, []{ return arrived; }); // 等待 arrived 变为 true
+    std::cout << "到达目的地，可以下车了！" << std::endl;
+}
+
+void simulateArrival() {
+    std::this_thread::sleep_for(std::chrono::seconds(5)); // 模拟地铁到站，假设5秒后到达目的地
+    {
+        std::lock_guard<std::mutex> lck(mtx);
+        arrived = true; // 设置条件变量为 true，表示到达目的地
+    }
+    cv.notify_one(); // 通知等待的线程
+}
+```
+
+> [运行](https://godbolt.org/z/eEaMhEanx)测试。更换为 `std::condition_variable_any` 效果[相同](https://godbolt.org/z/8dcPsKd5q)。
+
+- `std::mutex mtx`: 创建了一个互斥量，用于保护共享数据的访问，确保在多线程环境下的数据同步。
+
+- `std::condition_variable cv`: 创建了一个条件变量，用于线程间的同步，当条件不满足时，线程可以等待，直到条件满足时被唤醒。
+
+- `bool arrived = false`: 设置了一个标志位，表示是否到达目的地。
+
+在 `waitForArrival` 函数中：
+
+1. `std::unique_lock<std::mutex> lck(mtx)`: 使用互斥量创建了一个独占锁。
+
+2. `cv.wait(lck, []{ return arrived; })`: 在等待期间，当前线程会**释放锁**（unlock）并**等待**条件变量 `arrived` 变为 true。`cv.wait` 方法会自动释放锁并将当前线程加入到条件变量的等待队列中，直到被唤醒。
+
+3. 一旦条件满足，即 `arrived` 变为 true，并且当前线程被其它线程唤醒，那么当前线程会重新获取锁（lock），并执行后续的操作。
+
+在 `simulateArrival` 函数中：
+
+1. `std::this_thread::sleep_for(std::chrono::seconds(5))`: 模拟地铁到站，暂停当前线程 5 秒。
+
+2. 设置 `arrived` 为 true，表示到达目的地。
+
+3. `cv.notify_one()`: 通知等待在条件变量上的一个线程，唤醒其中一个等待线程。
+
+这样，当 `simulateArrival` 函数执行后，`arrived` 被设置为 true，并且通过 `cv.notify_one()` 唤醒了等待在条件变量上的线程，从而使得 `waitForArrival` 函数中的等待结束，可以执行后续的操作，即输出提示信息。