c++ - 线程作为类，如何确保子类的数据被销毁？

Question

我写了一个模拟 java 线程的 pthread/windows native 线程的包装器。

class Thread{
public:
  virtual void run()=0;
  void start();
  void join();

  virtual ~Thread(){
   join(); 
  }
};

假设

 class B:public Thread{
  int x;     
  void run(){
    while some condition do soemething on x;
  }
};

如果 B 的实例在 run() 返回之前被析构，线程将继续访问 x，这显然是不可取的。为了解决我需要添加的问题

B::~B(){
 join();
} 

因为 Thread::~Thread() 在 B::x 被销毁后被调用，所以 join 不会有任何效果。

但是，如果我有 class C: public B 和一些额外的数据，我仍然需要定义 C::~C(){join();}

依此类推，层级向下

另一种方法是做

template<typename R>
 struct SafeThread:public R,public Thread{
  void run(){
    R::run();
  }
};

这样 R 数据(我们之前的 B::x )将在线程加入后被销毁。不过，还是

class B{
  virtual void f(){...}
  void run(){ f();}
};


class C:public SafeThread<B>{
  int y;
  void f(){
  ...something on y;
  }

}; 

还是会有类似的问题。您是否认为有任何优雅的解决方案可以解决确保在 run 方法终止后销毁数据的问题，而无需强制每个子类 SC 定义 SC::~SC(){join();} ？

Answer 1

你可以写下你的Thread类作为接受任何类的模板 operator() ，当 Thread::run() 时相应调用叫做。下面的代码展示了这个想法。如有必要，请进行更改。

template<typename T>
class MyThread
{
    T & _obj;
    MyThread() = delete;
    MyThread(T& o) : _obj(o) {}
    void run() 
    {
        _obj();
    }
    // other member functions
};

struct B {
    int data_to_process;
    void operator()() {
        // do something with data
    }
}

// usage
B b;
MyThread<B> t(b);
t.run();