使用线程销毁类析构函数中的shared_ptr成员变量

Question

I am trying to recreate destroying a shared_ptr member variable in the bar class destructor using a thread which I feel may be the reason for a heap corruption. I personally feel it is strange to use a thread in a destructor, so I want the opinion from SO.

The pointer may outlive the application , so using detach is more desirable. The destructor is not called if detach used, however it works if join .

1) Is it wrong to reset a smart pointer this way?

2) Why the destructor is not called when std::thread::detach() was used ?

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

using namespace std;

class foo
{
    public:
    foo(){longcomputation();}
    void longcomputation() 
    { 
        std::cout<<" long computation called \n";
        std::this_thread::sleep_for(std::chrono::seconds(1)); 
    }
};

class bar
{
    public:
    bar(): foo_(std::make_shared<foo>()) {}
    ~bar() 
    {
        std::thread([foo = std::move(foo_)] () mutable
        {
          foo.reset();
          std::cout<<" bar dctor called \n";
        }).detach();  // ==========> works with join however
    }
    private:
    std::shared_ptr<foo> foo_;
};



int main()
{
    bar bar1;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "Exiting\n";
}

Answer 1

This does look like a bad way to handle threads and smart pointers and though I am not some C++ Guru, I would say this is a bad way to code in C++ overall (there will almost surely be issues of readability maintainability etc.).

Coming to the destructor, before the detached thread could be scheduled, the destructor exits, destroying the foo_ object and hence, std::move(foo_) fails. And when you use join() instead of detach() , you are making the destructor wait for the thread, which is why it works. It would also work if we build a sleep in the destructor after detaching the thread:

~bar()
{
    std::thread([foo = std::move(foo_)] () mutable
    {
      foo.reset();
      std::cout<<" bar dctor called \n";
    }).detach();  // ==========> works with join however
    // this works too
    std::this_thread::sleep_for(std::chrono::seconds(1));
}