承接上一篇：

从 0 开始讲透 C++ Lambda（对标 Java）
👉 你已经掌握了：

✔ lambda 结构
✔ capture（捕获）
✔ params（参数）
✔ lambda 本质（函数对象）

但在真实工程中，很多人会踩一个非常隐蔽的坑👇

一、问题：这段代码有没有问题？

#include <iostream>
#include <thread>

int main() {
    int a = 10;

    std::thread t([&]{
        std::cout << a << std::endl;
    });

    t.detach(); // 分离线程
}

👉 看起来很正常：

✔ 捕获 a
✔ 在线程中使用

👉 但实际上：

❗ 这段代码是未定义行为（可能崩溃）

二、问题本质：生命周期（核心）

👉 主线程流程

main 结束 → a 被销毁

👉 子线程流程

线程还在跑 → 访问 a

👉 结果：

访问了一个“已经销毁的变量” ❌

👉 这就是：

悬空引用（dangling reference）

三、为什么 [&] 会出问题？

[&] 的含义

引用捕获（reference capture）

👉 本质：

lambda 里用的不是值，而是“外部变量本身”

👉 所以：

外部变量没了 → lambda 里也没了

四、对比 [=]（关键）

改成值捕获

std::thread t([=]{
std::cout << a << std::endl;
});

👉 本质：a 被拷贝进 lambda

👉 即使：main 结束

👉 lambda 里还有：自己的 a 副本 ✔

👉 所以：线程安全 ✔

五、最核心对比（必须记）

capture 对比

写法	行为	生命周期
[&]	引用外部变量	❌ 依赖外部
[=]	拷贝变量	✔ 独立存在

六、为什么 thread 特别容易出问题？

👉 因为：线程是“异步执行”

👉 主线程和子线程：不是同步的

👉 所以：你不能保证：变量还活着

七、正确写法（工程建议）

✅ 推荐：值捕获

std::thread t([a]{
std::cout << a << std::endl;
});

✅ 或：保证生命周期

t.join(); // 等待线程结束

👉 这样：a 一定还活着 ✔

八、再深入一点（面试加分）

👉 这个问题本质是：

lambda + 引用 + 生命周期

👉 对应 C++ 三大核心：

✔ 内存管理
✔ 生命周期
✔ 并发

👉 面试可以这么说：

引用捕获在异步场景下容易产生悬空引用问题，因此推荐使用值捕获或保证变量生命周期

九、再给你一个真实工程坑

for (int i = 0; i < 3; i++) {
std::thread t([&]{
std::cout << i << std::endl;
});
t.detach();
}

👉 你以为输出： 0 1 2 ❌

👉 实际可能： 3 3 3 ❗

👉 原因：

i 被引用捕获
循环结束后 i = 3
线程才执行

十、正确写法👇

std::thread t([i]{
std::cout << i << std::endl;
});

👉 每个线程都有自己的副本 ✔

十一、总结（笔记版）

lambda 捕获在多线程中的问题：

[&]（引用捕获）：
- 使用外部变量本身
- 依赖外部生命周期
- 容易悬空引用（危险）

[=]（值捕获）：
- 拷贝变量
- 生命周期独立
- 更安全（推荐）

核心：
线程是异步的，变量可能提前销毁

十二、一句话总结（直接背🔥）

在多线程中使用 lambda 时，引用捕获可能导致悬空引用，优先使用值捕获或确保变量生命周期安全

十三、你现在掌握了什么（很关键）

你已经打通：

✔ lambda 捕获机制
✔ 生命周期问题
✔ 多线程安全
✔ 工程级坑

👉 这已经是：

C++ 并发 + lambda 核心能力🔥

下一篇：（继续打通）

👉 《C++ Lambda 深入：为什么 lambda 本质是一个类？》

这一篇会帮你彻底理解：

lambda → 类 → operator() → 可调用对象

👉 一旦通了：

STL / thread / 回调 全部打通