当类成员包含“ std :: shared_ptr”时为什么会崩溃 <std::thread> “？

Question

I found that my app will crash when class member contains "std::shared_ptr". For example:

#include <thread>
#include <memory>

class Derived {
public:
    Derived() {
        mThread = std::make_shared<std::thread>(&Derived::callback, this);
    }
    ~Derived() { }

    void callback() {}

    int add(int x, int y) { return x + y; }

private:
    std::shared_ptr<std::thread> mThread;
};

int main() {
    Derived * base = new Derived();
    delete base;
    return 0
}

I would like to know why?

Answer 1

When you are starting threads then you must join or detach them before thread's destructor gets called. I propose to do this in a destructor:

#include <thread>
#include <memory>

class Derived
{
public:
    Derived()
    {
        mThread = std::make_shared<std::thread>(&Derived::callback, this);
    }
    ~Derived()
    {
        if(mThread->joinable())
            mThread->join();
    }
    void callback() {}
    int add(int x, int y) { return x + y; }
private:
    std::shared_ptr<std::thread> mThread;
};

int main()
{
    Derived * base = new Derived();
    delete base;
    return 0;
}

By the way, using shared_ptr in your example is not necessary. You can simply define thread variable:

thread mThread;

Start new thread:

mThread = std::thread(&Derived::callback, this);

And join it, when you need:

mThread.join();

Answer 2

I think you have a design flaw, as you use shared_ptr for the thread without guaranteeing ownership of Derived.

As indicated by snake_style, you should join your thread.

I'm gonna argue that you should store the thread by value in your class to guarantee lifetime of Derived:

#include <thread>
#include <memory>

class Derived {
 public:
    Derived() {
        mThread = std::thread(&Derived::callback, this);
}
~Derived() { 
        if (mThread.joinable())
              mThread.join();
}

    void callback() {}

    int add(int x, int y) { return x + y; }

private:
    std::thread mThread;
};

The if-statement in the Dtor protects you from incorrect behavior when Derived gets moved.

Another way of guaranteeing ownership is putting Derived in the thread:

 thread = std::thread([d = Derived{}]() mutable { d.callback(); };

This moves the thread variable out of the class.

A third solution could be putting Derived in a shared_ptr and using an alias constructor of shared_ptr to create the threads shared pointer. I don't work this out as this might be too tricky and you could as well put the shared_ptr as capture in your lambda.

Answer 3

If you want to store the thread in a shared_ptr it would be better to create a factory function with a shared_ptr custom deleter which joins the thread.

#include <thread>
#include <memory>
#include <iostream>

template<typename... Args>
std::shared_ptr<std::thread> makeThread(Args&&... args)
{
    return std::shared_ptr<std::thread>(new std::thread(std::forward<Args>(args)...)
                                        , [](std::thread* t) { t->join(); delete t; });
}

void test(std::int32_t &v)
{
    for (int workload = 0; workload < 64; ++workload)
        ++v;
}

int main(int argc, char *argv[])
{  
    std::int32_t v = 0;
    auto sptr_thread = makeThread(test, std::ref(v));
    std::cout << "value before exiting: " << v << std::endl;

    return 0;
}

Unlike the std::shared_ptr constructors, std::make_shared does not allow a custom deleter. I would prefer the factory as it's not possible to forget joining the thread