条件变量 cv：用于线程间的等待与通知。std::unique_lock（主线程用）。std::lock_guard（子线程用）

下面我用更简单直观的方式，逐步带你理解清楚：

🔑 整个流程重新用通俗的话再讲一遍：

先明确几个关键角色：

• 互斥量 (mutex)：确保同一时间只有一个线程访问共享数据（这里就是变量ready）。
• 条件变量 cv：用于线程间的等待与通知。
• 锁管理器：
  • std::unique_lock（主线程用）：灵活，可以手动解锁或重新上锁。
  • std::lock_guard（子线程用）：简单，自动加锁与解锁。

---

🚩 代码流程通俗讲解：

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

---

【主线程流程】：

主线程代码片段：

std::unique_lock<std::mutex> lock(mtx);
std::cout << "主线程等待子线程的通知...\n";
cv.wait(lock, []{ return ready; }); // 这里是关键

主线程执行过程：

1. std::unique_lock<std::mutex> lock(mtx);

   • 主线程此时给mtx 上了锁。
   • 如果锁成功（没其他线程占用），继续向下执行。

2. 主线程进入cv.wait(lock, []{ return ready; });：

   • 先检查ready：
     • 如果ready == true，不等待，直接往下走。
     • 如果ready == false，主线程必须等待子线程通知。

   这时候，主线程暂时无法继续，必须等待。

3. 主线程自动释放锁：

   • 为了让子线程能顺利更新ready的值，主线程在等待时自动解锁（释放mtx）。
   • 主线程进入阻塞状态（睡眠）。

---

子线程的执行过程：

{
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
}
cv.notify_one();

子线程过程：

1. 加锁：

   • 执行到{}内部时，lock_guard自动调用mtx.lock()。
   • 若主线程已经释放了锁，此时子线程顺利拿到锁，进入临界区。

2. 修改变量：

   • 将ready从false改为true。

3. 自动解锁：

   • 执行完{}代码块，子线程lock_guard自动解锁。
   • 此时mtx.unlock()自动调用。

4. 通知主线程：

   • cv.notify_one()告诉主线程：“你可以醒来了”。

---

🔑 这里为什么主线程能自动醒来？

因为主线程此刻正处在：

cv.wait(lock, []{ return ready; });

主线程醒来后自动重新加锁，相当于做下面这些事：

• 收到子线程的notify_one()，主线程醒来。
• wait()内部自动重新执行：

  lock.lock(); // 重新拿到锁
  if (ready == true) {
      return; // 条件满足，主线程继续
  } else {
      lock.unlock(); // 若条件未满足，再次等待（这里的代码帮你自动完成）
      cv.wait(lock);
  }
  

因此这个过程实际是循环的，直到条件满足。

---

### 🚩 **用生活中的例子解释一下**：

假设：

- **主线程**是一个正在等待的人，等待某个信号才继续做事。
- **子线程**则是负责给主线程发送通知的角色。

> 想象主线程在等一个快递包裹（信号）。

- 主线程先打开门锁（`mtx`），确认没有快递（`ready == false`），于是关门，但门不上锁，坐在门口等待快递（`cv.wait()`会自动解锁，坐着等待通知）。
- 快递员（子线程）拿到了快递，想要送进门，发现门没锁（因为主线程暂时解锁了），于是进来放下快递（将`ready = true`）。
- 快递放下后，快递员出门顺手带门（自动释放锁`lock_guard`自动解锁），通知主线程：“包裹到了，你可以看了！”（`notify_one()`）。

- 主线程听到通知后，站起来重新开门确认（`wait`自动重新加锁，确认`ready == true`），包裹确实到了，于是取出包裹，继续做后面的事情。

---

## 🔑 重要步骤明确总结：

| 时刻  | 动作 | 主线程状态 | 子线程状态 | mtx锁的状态 |
| ----- | ------ | ----------- |
| 起始 | 主线程加锁，检查条件 | 🔒 已上锁（主线程）|
| 主线程等待时 | 条件不满足，自动解锁 | 🔓 已解锁|
| 子线程启动时 | 拿到锁，修改变量 | 🔒 已上锁（子线程）|
| 子线程结束时 | 修改完毕，自动解锁 | 🔓 已解锁|
| 子线程通知时 | 主线程醒来重新上锁，条件满足继续 | 🔒 已上锁（主线程）|

---

## 🌟 **整体再一句话总结**：

- **主线程先加锁**，发现条件不满足，**自动释放锁并进入等待**；
- 子线程得到锁，执行完任务后，设置条件为满足，**自动释放锁后通知主线程**；
- 主线程收到通知后，**自动重新加锁**检查条件，满足后继续执行。

---

## 💡 注意的核心点：

- `std::unique_lock` 可以自动释放、重新获取锁（灵活）。
- `cv.wait()` 和 `cv.notify_one()`是成对使用的：
  - `wait()`自动释放锁后等待；
  - 收到通知后，自动重新获得锁并检查条件。

这个过程你无需手动进行解锁与加锁，C++条件变量的API会自动帮你完成。

---

## 🚩 总结一句话：

- **`unique_lock`自动帮主线程释放锁（进入等待）和重新加锁（收到通知）**；
- **`lock_guard`自动帮子线程加锁（访问资源）和自动释放锁（任务完成）**；
- 主线程与子线程交替拿到锁，保证线程安全。

这就是你代码里锁定和解锁的详细流程。