如何在退出之前重新连接线程或等待线程完成

Question

I have an application that connects to a socket using the asio library. My main thread calls an open() to the socket implementation where it is then detached from the main thread to continue execution.

When thread::detach() is called, the thread can no longer be joined and thus the caller has no idea when the thread has completed its execution. This results, at least in my application, of an unclean shutdown. Resources aren't deallocated properly and, only sometimes, leads to a crash. Is it possible to rejoin the detached thread? I would like to try and avoid using a condition variable.

Here is my example:

io_socket io = new io_socket();

// The call to thread::detach() is done within io_socket::open()
io->open();

// Let some things happen...
std::this_thread::sleep_for(std::chrono::seconds(20));

// Safely kills all operations and resources before delete
io->close();

// A hack solution to allow time for the detached thread to do what it needs to do
//std::this_thread::sleep_for(std::chrono::milliseconds(1000));

// Crashes if I don't allow the detached thread to safely close
delete io;

return EXIT_SUCCESS;

Answer 1

You cannot reattach a std::thread that you have detached. The only way to wait for a detach thread to end is to use some sort of atomic/condition variable to notify you when it it done.

That said, you probably don't need to detach the thread in the first place. What you can do is create storage for the threads to live in ( std::vector<std::thread> comes to mind) and then in open you add the new thread to that storage. Once you are all done you call close and have close go through every thread in the storage and call join on it. This will make close your synchronization point and after that you know that all threads have ended and you are safe to close the application.

Answer 2

Assuming that the IO thread is coded by you, you can handle this with a combination of std::promise and std::future , something like this:

#include <chrono>
#include <thread>
#include <future>
#include <iostream>

using namespace std::chrono_literals;

void demo_thread (std::promise <bool> *p)
{
    std::cout << "demo thread waiting...\n";
    std::this_thread::sleep_for (1000ms);
    std::cout << "demo thread terminating\n";
    p->set_value (true);
}

int main ()
{
    std::promise <bool> p;
    std::thread t = std::thread (demo_thread, &p);
    t.detach ();

    // ...

    std::cout << "main thread waiting...\n";
    std::future <bool> f = p.get_future();
    f.wait ();

    std::cout << "main thread terminating\n";
}

Live demo

Answer 3

Is it possible to rejoin the detached thread?

No. That would defeat the whole purpose of detach() .

A t.detach() call does not actually do anything essential. It's only purpose is to disable a safety mechanism.

Normally, if you don't detach() a thread, then the destructor for the thread object will throw an error if you allow the object to be destroyed before your program has join()ed it. The only purpose for that is to help you to avoid a common mistake: It's meant to prevent your main() routine from exiting and terminating the program before all of the other threads have finished.

The purpose of t.detach() ---the only purpose---is to tell the library, "Thanks, but I know what I'm doing, I don't want the help, and I am NEVER going to call t.join() .

---

If you want your program to call t.join() then don't call t.detach() .

Answer 4

NathanOliver has provided a good answer, but his solution may prove difficult if the io->open() function does not return a reference to the std::thread object it creates (which, if it detaches, it likely doesn't). If you are using the Asio library directly, I would expect that io->close() should be properly handling graceful exit of the thread before you delete io . However, if this is a wrapper you've implemented, you either need to return a reference to the created thread object in open() , or change your implementation of close() so that it blocks until the resources have actually been deallocated. Furthermore, if these are methods implemented yourself, is the detach in open() even necessary?