今天复习前几年在项目过程中积累的各类技术案例，有一个小的 coredump 案例，当时小组里几位较资深的同事都没看出来，后面是我周末查了两三个小时解决掉的，今天再做一次系统的总结，给出一个复现的案例代码，案例代码比较简单，便于学习理解。
1. 简介
原则：临时对象不应该被 lambda 引用捕获，因为临时对象在它所在的语句结束就会被析构掉，只能采用值捕获。
当临时对象比较隐蔽时，我们就可能犯这个低级错误。本文介绍一类case：以基类智能指针对象的 const 引用为函数形参，并在函数内对该参数做引用捕获，然后进行跨线程异步使用。当函数调用者使用派生类智能指针作为实参时，此时派生类智能指针对象会向上转换为基类智能指针对象，这个转换是隐式的，产生的对象是临时对象，然后被 lambda 引用捕获，后续跨线程使用引发“野引用” core。
2. 案例
下面写一个简单的 demo 代码来模拟这个案例。案例涉及的代码流程，如下图所示：
其中，基类 BaseTask，派生类 DerivedTask，main 函数将 lambda 闭包抛到工作线程中异步执行。
详细示例代码如下：
代码语言：cpp复制/**
* @brief 关键字：lambda、多线程、std::shared_ptr 隐式向上转换
* g main.cc -std=c 17 -O3 -lpthread
*/
#include <atomic>
#include <chrono>
#include <functional>
#include <iostream>
#include <memory>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
using namespace std::chrono_literals;
/// 简易线程池
template <typename Func>
class ThreadPool {
public:
~ThreadPool() {
stop_ = true;
for (auto& item : workers_) {
item.join();
}
}
void Run() {
static constexpr uint32_t kThreadNum = 2;
uint32_t idx = 0;
for (uint32_t idx = 0; idx != kThreadNum; idx) {
workers_.emplace_back(std::thread([this, idx] { ThreadFunc(idx); }));
mutexs_.emplace_back(std::make_shared<std::mutex>());
}
job_queues_.resize(kThreadNum);
}
void Stop() { stop_ = true; }
bool Post(Func&& f) {
if (!stop_) {
uint32_t index = job_cnt_ % job_queues_.size();
auto& queue = job_queues_[index];
std::lock_guard<std::mutex> locker(*mutexs_[index]);
queue.push(std::move(f));
return true;
}
return false;
}
void ThreadFunc(uint32_t idx) {
auto& queue = job_queues_[idx];
auto& mutex = *mutexs_[idx];
// 退出前清空任务队列
while (true) {
if (!queue.empty()) {
std::lock_guard<std::mutex> locker(mutex);
const auto& job_func = queue.front();
job_func();
queue.pop();
} else if (!stop_) {
std::this_thread::sleep_for(10ms);
} else {
break;
}
}
}
private:
/// 工作线程池
std::vector<std::thread> workers_;
/// 任务队列，每个工作线程一个队列
std::vector<std::queue<Func>> job_queues_;
/// 任务队列的读写保护锁，每个工作线程一个锁
std::vector<std::shared_ptr<std::mutex>> mutexs_;
/// 是否停止工作
bool stop_ = false;
/// 任务计数，用于将任务均衡分配给多线程队列
std::atomic<uint32_t> job_cnt_ = 0;
};
using MyThreadPool = ThreadPool<std::function<void()>>;
/// 基类task
class BaseTask {
public:
virtual ~BaseTask() = default;
virtual void DoSomething() = 0;
};
using BaseTaskPtr = std::shared_ptr<BaseTask>;
/// 派生task
class DeriveTask : public BaseTask {
public:
void DoSomething() override {
std::cout << "derive task do someting" << std::endl;
}
};
using DeriveTaskPtr = std::shared_ptr<DeriveTask>;
/// 示例用户
class User {
public:
User() { thread_pool_.Run(); }
~User() { thread_pool_.Stop(); }
void DoJobAsync(const BaseTaskPtr& task) {
// task 是 user->DoJob 调用产生的临时对象，捕获它的引用会变成也指针
thread_pool_.Post([&task] { task->DoSomething(); });
}
private:
MyThreadPool thread_pool_;
};
using UserPtr = std::shared_ptr<User>;
/// 测试运行出 core
int main() {
auto user = std::make_shared<User>();
DeriveTaskPtr derive_task1 = std::make_shared<DeriveTask>();
// derive_task 会隐式转换为 BaseTask 智能指针对象，
// 该对象是临时对象，在 DoJob 执行完之后生命周期结束。
user->DoJobAsync(derive_task1);
DeriveTaskPtr derive_task3 = std::make_shared<DeriveTask>();
user->DoJobAsync(derive_task3);
std::this_thread::sleep_for(std::chrono::seconds(3));
return 0;
}上面这个例子代码，会出现 coredump，或者是没有执行派生类的 DoSomething，总之是不符合预期。不符合预期的原因如下：这份代码往一个线程里 post lambda 函数，lambda 函数引用捕获智能指针对象，这是一个临时对象，其离开使用域之后会被析构掉，导致 lambda 函数在异步线程执行时，访问到一个"野引用"出错。而之所以捕获的智能指针是临时对象，是因为调用 User.DoJobAsync 时发生了类型的向上转换。
上述的例子还比较容易看出来问题点，但当我们的项目代码层次较深时，这类错误就非常难看出来，也因此之前团队里的资深同事也都无法发现问题所在。
这类问题有多种解决办法：
（1）方法1：避免出现隐式转换，消除临时对象；
（2）方法2：函数和 lambda 捕获都修改为裸指针，消除临时对象；引用本质上是指针，需要关注生命周期，既然采用引用参数就表示调用者需要保障对象的生命周期，智能指针的引用在用法上跟指针无异，那么这里不如用裸指针，让调用者更清楚自己需要保障对象的生命周期；
（3）方法3：异步执行时采用值捕获/值传递，不采用引用捕获，但值捕获可能导致性能浪费，具体到本文的例子，这里的性能开销是一个智能指针对象的构造，性能损耗不大，是可接受的。
3. 其他
临时对象的生命周期可以参考这篇文档：https://en.cppreference.com/w/cpp/language/reference_initialization#Lifetime_of_a_temporary
