如何解决基类与派生类数据依赖及线程析构异常问题

问题代码 #

class Base
{
public:
    Base() { task_ = std::thread(&Base::running_task, this); }
    virtual ~Base(){ /* 发送停止信号给task_ */ task_.join();}

protected:
    virtual int some_check(int) = 0;

private:
    void running_task() { some_check(123); }
    std::thread task_;
};

class Derived : public Base
{
protected:
    int some_check(int) override; // 内部使用my_data

private:
    std::string my_data = "test";
};

问题根源 #

你推测的原因完全正确：C++中派生类对象的析构顺序是先销毁派生类成员（如my_data），再执行基类析构函数。基类析构时才通知线程停止并等待，但此时线程可能仍在运行，调用some_check访问已销毁的my_data，触发未定义行为（如异常、崩溃）。

最优解决方案 #

不需要每个派生类都重写析构，核心思路是让线程在派生类成员销毁前完全停止，以下是两种落地方案：

方案一：基类提供停止接口，派生类析构时主动调用

给基类添加线程停止的接口，派生类析构时先调用该接口，确保线程在成员销毁前结束：

#include <atomic>
#include <thread>
#include <chrono>

class Base
{
public:
    Base() : task_(&Base::running_task, this) {}
    
    // 禁止拷贝移动，避免线程资源混乱
    Base(const Base&) = delete;
    Base& operator=(const Base&) = delete;
    Base(Base&&) = delete;
    Base& operator=(Base&&) = delete;

protected:
    virtual int some_check(int) = 0;
    
    // 供派生类调用的线程停止接口
    void stop_thread() {
        stop_flag_.store(true, std::memory_order_relaxed);
        if (task_.joinable()) {
            task_.join();
        }
    }

private:
    void running_task() {
        // 循环检查停止标志，避免线程无限执行
        while (!stop_flag_.load(std::memory_order_relaxed)) {
            some_check(123);
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }
    
    std::thread task_;
    std::atomic<bool> stop_flag_{false}; // 线程停止标志
};

class Derived : public Base
{
public:
    ~Derived() {
        stop_thread(); // 先停止线程，再销毁my_data
    }

protected:
    int some_check(int) override {
        return my_data.size(); // 安全访问my_data
    }

private:
    std::string my_data = "test";
};

方案二：用混入类（Mixin）封装停止逻辑，避免重复代码

如果有多个派生类，可以用模板混入类统一处理线程停止，不用每个派生类都写析构：

template<typename BaseClass>
class ThreadStopper : public BaseClass
{
public:
    ~ThreadStopper() {
        this->stop_thread();
    }
    
    // 转发基类构造参数，适配任意构造函数
    template<typename... Args>
    ThreadStopper(Args&&... args) : BaseClass(std::forward<Args>(args)...) {}
};

// 派生类只需继承ThreadStopper<Base>
class Derived : public ThreadStopper<Base>
{
protected:
    int some_check(int) override {
        return my_data.size();
    }

private:
    std::string my_data = "test";
};

核心注意事项 #

• 必须给线程添加停止标志，确保running_task能响应停止信号，否则join会永久阻塞。
• 禁止基类的拷贝和移动操作，避免线程资源被意外复制或转移。
• 始终保证线程停止逻辑在派生类成员销毁前执行，这是解决问题的核心原则。

内容的提问来源于stack exchange，提问作者qwark