今天复习前几年在项目过程中积累的各类技术案例，有一个小的 coredump 案例，当时小组里几位较资深的同事都没看出来，后面是我周末查了两三个小时解决掉的，今天再做一次系统的总结，给出一个复现的案例代码，案例代码比较简单，便于学习理解。

1. 简介

原则：临时对象不应该被 lambda 引用捕获，因为临时对象在它所在的语句结束就会被析构掉，只能采用值捕获。
当临时对象比较隐蔽时，我们就可能犯这个低级错误。本文介绍一类case：以基类智能指针对象的 const 引用为函数形参，并在函数内对该参数做引用捕获，然后进行跨线程异步使用。当函数调用者使用派生类智能指针作为实参时，此时派生类智能指针对象会向上转换为基类智能指针对象，这个转换是隐式的，产生的对象是临时对象，然后被 lambda 引用捕获，后续跨线程使用引发“野引用” core。

2. 案例

下面写一个简单的 demo 代码来模拟这个案例。案例涉及的代码流程，如下图所示：

其中，基类 BaseTask，派生类 DerivedTask，main 函数将 lambda 闭包抛到工作线程中异步执行。
详细示例代码如下：

/**
 * @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