destroy thread's object from a joinable thread

Question

struct Foo
{
   boost::thread thread_;

   void launchThread()
   {
       boost::thread(boost::bind(&Foo::worker, this));
   }

   void worker()
   {
     ~Foo(); 
   }

   ~Foo()
   {
      if (boost::this_thread::get_id() != thread_.get_id())
        thread_.join();
   }

};

In c++11 is it legal in a joinable thread to call the destructor of the class which declare the thread?

EDIT1 , more realistic example:

struct Holder
{
   std::unique_ptr<SocketClient> client_;
   void ondisconnected(){client_.release();}
   Holder()
   {
      //create SocketClient and launch the thread
   }
}

struct SocketClient 
{
    boost::thread thread_;

    void launchThread()
    {
       boost::thread(boost::bind(&SocketClient ::worker, this));
    }

    void worker()
    {
        run_ = true;
        while (run_)
        { 
            boost::system::error_code error;

            auto receveidBytesCount = socket_.read_some(boost::asio::buffer(socketBuffer_), error);

            if (error == boost::asio::error::eof)
            {
               disconnected_() // call Holder slot  
               return;          
            }
        }
    }

    ~SocketClient ()
    {
        run_ = false;
        socket_.shutdown(boost::asio::socket_base::shutdown_both);
        socket_.close();

        if (boost::this_thread::get_id() == thread_.get_id())
           thread_.detach();
        else
           thread_.join(); 
    }
};

Answer 1

No. A joinable thread must be joined or detached before the thread object is destroyed. This will do neither if called from that thread. The thread's destructor will call terminate() , ending the program.

Whether it's acceptable to detach the thread depends on whether you're also destroying objects which the thread accesses. That rather depends on the large-scale design of your thread interactions, and can't really be answered in general.

Note that explicitly calling the destructor like that is almost certainly not valid; I assume that's just to illustrate that the destructor is being called (in a more suitable manner) on the thread.