了解std :: thread语义，并以worker函数作为类成员

Question

To implement the logic when contructed object starts background thread for real work, I'm using a pattern like this (simplified):

class A {
    std::thread t{&A::run, this};
    std::atomic_bool done;
    // variables are the question about
    std::vector<std::thread>  array_for_thread_management;

    // ... and other members
protected:
    void run() {
        ...
        array_for_thread_management.push_back([](){...});
        ...
   }
public:
    A() = default;
    // all other constructors deleted because of used 
    // some members like std::atomic_bool done;
    ~A() {
        done = true;
        bi::named_condition         cnd{bi::open_only, "cnd"};
        cnd.notify_one();

        if (t.joinable())
            t.join();

        for(std::thread& worker : array_for_thread_management) {
            if (worker.joinable()) worker.join();
        }
    }


};

If I'm adding a push of child threads in primary background thread into a vector in run() member, the object hangs on destructor. even there is no real threads in a vector, just started this without connections from outside and try to stop this by destructor

Answer 1

Of course, once you have this pointer in your run method, you can access class members via this pointer. I guess the problem with your code is that the thread is spawned before any other members are initialized, as it is the first member in your class definition. I suspect with the following definition of class A you'll have no problems with accessing member variables:

class A {
    std::atomic_bool done;
    // variables are the question about
    int i;
    std::string s;
    std::vector<std::string> v;
    // and only after everything above is initialized:
    std::thread t{&A::run, this}; // spawn a thread
    // ...
}

However, personally I would prefer having a separate method start() which spawns a thread to spawning it inside class constructor implicitly. It may look like this:

class A
{
    std::unique_ptr<std::thread> t;
    std::atomic<bool> some_flag;

public:
    void start()
    {
        t.reset(new std::thread(&A::run, this));
    }

private:
    void run()
    {
        some_flag.store(true);
    }
};