一行代码引发的线上崩溃，竟是因为这个 C++ Lambda 陷阱！

class Timer {
    int interval;
    function<void()> callback;
public:
    Timer(int ms) : interval(ms) {} 
    
    void setTimeout() {
        // ⚠️ 危险:这里使用[this]捕获可能导致悬空指针
        auto task = [this]() {
            callback();  // 💥 如果Timer对象已销毁,这里会崩溃!
        };
        scheduler.schedule(interval, task);
    }
};

class Timer {
    // ... 其他代码不变 ...
    void setTimeout() {
        // 🔑 使用[*this]进行值捕获,创建Timer对象的完整副本
        // 🛡️ 这样即使原Timer对象被销毁,Lambda也能安全运行
        auto task = [*this]() mutable {  
            // ✨ 在Timer副本上调用callback,完全安全
            // 💫 mutable关键字允许修改捕获对象的副本
            callback();  
        };
        // 📅 将任务提交给调度器
        // 🔄 调度器会持有task直到执行完成
        scheduler.schedule(interval, task);
    }
};

class Timer {
    void setTimeout() {
        // 🔄 创建Lambda时会发生以下过程:
        // 📦 1. 完整复制当前Timer对象(*this)
        // 🏃 2. Lambda获得独立的Timer副本
        auto task = [*this]() mutable {
            // ✨ 在Timer副本上调用callback
            // 🛡️ 即使原对象销毁也安全
            callback();
        };
        
        // 📋 调度器接管任务生命周期管理
        // 🔒 task对象会被scheduler安全持有
        scheduler.schedule(interval, task);
    }
    // 🚫 原Timer对象可能在此销毁
}; // ⌛ 原始Timer对象生命周期结束

// 🎯 Lambda中Timer副本的销毁时机:
// 1️⃣ scheduler停止运行时 - 任务队列清空
// 2️⃣ task执行完成时 - 调度器释放Lambda
// 3️⃣ scheduler销毁时 - 清理所有待执行任务

class Logger {
    // 📝 日志前缀,用于标识不同的日志来源
    string prefix;
    // 📂 文件输出流,用于写入日志文件
    std::shared_ptr<std::ofstream> file;
public:
    // 🏗️ 构造函数:初始化Logger并打开日志文件
    Logger(string p) : prefix(p) {
        // 📤 以追加模式打开日志文件
        file.open("log.txt", ios::app);
    }
    
    // 🎯 返回一个可以安全异步执行的日志回调函数
    auto getLogCallback() {
        // ✨ 使用[*this]创建整个Logger对象的独立副本:
        // 📦 - 包含prefix的完整副本
        // 📄 - 包含file对象的完整副本(文件句柄会被正确共享)
        return [*this]() mutable {
            // 📝 在Logger副本上执行写入操作
            // 🔒 即使原Logger对象被销毁也能安全运行
            // ⚡ mutable允许修改捕获的Logger副本
            file << prefix << ": " << getCurrentTime() << endl;
        };
    }
};

class ResourceManager {
    // 🔒 独占式智能指针,不支持复制
    unique_ptr<Resource> resource;
    // 🔐 互斥锁对象,也不支持复制
    mutex mtx;
    
    void processAsync() {
        // ⚠️ 以下代码存在严重问题:
        auto task = [*this]() {  // 💥 这里会尝试复制整个对象!
            // ❌ 错误1: mtx是副本,不同线程会获取不同的锁,失去了互斥作用
            lock_guard<mutex> lock(mtx);
            // ❌ 错误2: unique_ptr不支持复制,编译会失败
            resource->process();
        };
        // 📤 提交任务到线程池
        threadPool.submit(task);
    }
};

// ✅ 正确的实现方式:
class ResourceManager {
    // 👥 改用支持共享的智能指针
    shared_ptr<Resource> resource;
    
    // 🔐 使用静态互斥锁确保真正的线程安全
    static mutex& getMutex() { 
        static mutex mtx; 
        return mtx; 
    }
    
    void processAsync() {
        // 📦 只捕获需要的资源
        auto res = resource;  // 👍 shared_ptr支持复制
        
        auto task = [res]() {  // ✨ 显式捕获所需资源
            // ✅ 所有线程使用同一个互斥锁
            lock_guard<mutex> lock(ResourceManager::getMutex());
            // 🚀 安全地访问共享资源
            res->process();
        };
        // 📤 提交到线程池
        threadPool.submit(task);
    }
};