问使用共享指针从另一个线程进行纯虚拟调用

EN

class Thread : private std::thread {
    std::atomic_bool run {true};
public:
    Thread()
        // Here you are starting a separate thread of execution
        // That calls the method thread_fun on the current object.
        //
        // No problem so far. BUT you should note that "this" object
        // is not fully constructed at this point and there is no
        // guarantees that the thread you just started will wait
        // for this thread to finish before doing anything.
        : std::thread([this](){ thread_fun(); })
    {}

    void thread_fun() {
        // The new thread has just started to run.
        // And is now accessing the variable `run`.
        //
        // But `run` is a member and initialized after
        // the base class so you have no idea if the parent
        // thread has correctly initialized this variable yet.
        //
        // There is no guratnee that the parent will get to 
        // the initialization point of `run` before this new thread
        // gets to this point where it is using it.
        while (run) {

            // Here you are calling a virtual function.
            // The trouble is that virtual functions are not
            // guranteed to work as you would expect until all the
            // constructors of the object have run.
            //   i.e. from base all the way to most derived.
            //
            // So you not only have to wait for this base class to
            // be full constructed you must wait until the object
            // is full constructed before you call this method.
            loop_iteration();
        }
    }

    virtual void loop_iteration() = 0;

    virtual ~Thread() {
        // You have a problem in that std::thread destructor
        // is not virtual so you will not always call its destructor
        // correctly.
        //
        // But lets assume it was called correctly.
        // When you get to this point you have destroyed the
        // the state of all derived parts of your object.
        // So the function your thread is running better
        // not touch any of that state as it is not all invalid
        // and doing so is UB.
        //
        // If your object had no state then you are fine.

        run.exchange(false);

        join();
        std::cout << "Thread released." << std::endl;
    }
};

class Thread {
    std::atomic_bool run;
    std::thread      thread;
public:
    Thread(std::function<void>& hold)
        // Make sure run is initialized before the thread.
        : run{false}
        , thread([this, &hold](){ thread_fun(hold); })
    {}

    void thread_fun(std::function<void>& hold) {

        // Pass in a hold function.
        // The creator of your objects defines this
        // It is supposed to make objects created until you
        // have all the state correctly set up.
        // once it is you allow any threads that have called
        // hold to be released so they can execute.
        hold();
        
        while (run) loop_iteration();
    }

    virtual void loop_iteration() = 0;

    virtual ~Thread() {
        run.exchange(false);
        join();
        std::cout << "Thread released." << std::endl;
    }

};

class Barrier
{
    bool                        threadsShouldWait = true;
    std::conditional_variable   cond;
    std::mutex                  mutex;

    void wait() {
         std::unique_lock<std::mutex> lock(mutex);
         cond.wait([&](){return !threadsShouldWait;}, lock);
    }
    void release() {
         std::unique_lock<std::mutex> lock(mutex);
         threadsShouldWait = false;
         cond.notify_all();
    }
}

int main()
{
   // Note you don't need to use the same barrier for
   // both these variables. I am just illustrating one use case.
   Barrier   barrier;

   std::shared_ptr<Thread> receiver = std::make_shared<Receiver>([&barrier](){barrier.wait();});
   std::shared_ptr<Thread> notifier = std::make_shared<Sender>([&barrier](){barrier.wait();});

   barrier.release();

    `virtual ~Signal(){}`