What Happens to Detached Threads When the Main Thread Exits in C ?

Detached Threads in a Threading Void

In multithreaded programming, detached threads continue executing even after they've been separated from their original owner thread. This raises the question: when the main thread exits, what happens to detached threads that are still running?

The Standard Response

The C Standard (N3797) remains silent on the fate of detached threads when main() exits. Neither Section 1.10 (Program Termination) nor Section 30.3 (Threads) explicitly defines the behavior.

Despite this omission, it is generally assumed that detached threads continue running until they complete their execution. This assumption stems from the fact that threads are entities controlled by the operating system and may not be terminated by the program's main thread.

Potential Hazards

However, allowing detached threads to continue indefinitely can lead to undefined behavior if these threads access variables or static objects belonging to other threads or touch static objects after the destruction of static objects has concluded.

In particular, the C Standard (Section 1) states that after all thread objects have been destroyed and any potential signal handlers have finished executing, the only allowed code is that which is permitted in signal handlers (e.g., the library). This excludes most C library functionality, including condition variables.

Exceptional Approaches

To prevent undefined behavior while detached threads are still running when main() exits, developers can adopt one of two approaches:

• Manual Joining: Use the *_at_thread_exit functions (e.g., notify_all_at_thread_exit()) to signal the completion of detached threads before the main thread terminates. This ensures that the end of thread execution happens-before the reception of the signal by another waiting thread.
• Signal Handler Safety: Design detached threads to execute code that is safe for use within signal handlers. This ensures they can continue running even after the destruction of static objects has concluded.

Conclusion

Though the C Standard does not explicitly define the behavior of detached threads when main() exits, it can be inferred that they continue executing until completion. Developers should be aware of the potential hazards involved and employ appropriate measures (manual joining or signal handler safety) to avoid undefined behavior.

The above is the detailed content of What Happens to Detached Threads When the Main Thread Exits in C ?. For more information, please follow other related articles on the PHP Chinese website!