When is it impossible to join a stream?

Joining a thread (join) is not possible in the following cases:

• Thread already joined: Attempting to join a thread that has already finished and was previously joined leads to undefined behavior or an error.
• Thread was detached: A detached thread operates independently of the thread that created it. Its completion is not awaited by any thread, so attempting to join it makes no sense and will result in an error.
• Invalid thread (e.g., not created): Attempting to join a thread that was not successfully created or is a null handle will cause an error.
• Joining thread terminates: If the thread attempting to join another thread terminates before or during the join operation, the join may be interrupted or not occur at all.
• Deadlock situation: If two threads try to join each other simultaneously, a deadlock occurs, and the join operation will not complete.
• Exception during thread execution: An unhandled exception in a thread can make its state undefined, and attempting to join it may be incorrect.
• Process termination: Terminating the entire process ends all its threads, including those possibly waiting to join.

Example of a detached thread in C++11:

#include <thread>
#include <iostream>

void worker_function() {
    std::cout << "Worker thread running." << std::endl;
}

int main() {
    std::thread t(worker_function);
    t.detach(); // Detach the thread
    // Now t cannot be joined

    // Attempting to join will throw std::system_error
    // try {
    //     t.join();
    // } catch (const std::system_error& e) {
    //     std::cerr << "Error joining thread: " << e.what() << std::endl;
    // }

    std::cout << "Main thread finished." << std::endl;
    return 0;
}

In this case, after calling detach(), thread t continues to run independently. The main thread does not wait for its completion, and calling t.join() after detach() will throw a std::system_error exception.