Why is using exit() considered bad? [duplicate]

by

Just blindly calling exit() somewhere in your program is considered bad for a simple reason:

It does not properly shutdown other threads (they just get terminated), it does not properly flush all buffers (stdio files are flushed) and guarantee a consistent and valid state of permanent/shared resources (files/shared memory/other ways to communicate).

Still, if you can guarantee that no thread is running which might interfere (by being killed holding a lock or such), and all buffers which need it will be flushed by exit(), that’s a valid way to achieve a faster shutdown.

Much modern software is programmed for even faster shutdown:

It is crash-tolerant, in that at nearly every time, just shutting down using e.g. _Exit() (not even calling atexit or at_quick_exit registered hooks) is ok. That is vastly faster than an ordered shutdown in most cases (Windows user interface resources should be destroyed first if possible, because they are an exception).

For further reading: Crash-only software (PDF!)

Crash-only programs crash safely and recover quickly.
There is only one way to stop such software – by crashing
it – and only one way to bring it up – by initiating recovery.
Crash-only systems are built from crash-only components,
and the use of transparent component-level retries
hides intra-system component crashes from end users. In
this paper we advocate a crash-only design for Internet systems,
showing that it can lead to more reliable, predictable
code and faster, more effective recovery. We present ideas
on how to build such crash-only Internet services, taking
successful techniques to their logical extreme.

More Related Contents:

  1. Using paragraphs 8.5.3p4 and p5 in the C++11 Standard, how do I prove that the snippet below doesn’t compile?
  2. Why aren’t variable-length arrays part of the C++ standard?
  3. Where do I find the current C or C++ standard documents?
  4. Array placement-new requires unspecified overhead in the buffer?
  5. Is “argv[0] = name-of-executable” an accepted standard or just a common convention?
  6. What are the new features in C++17?
  7. What’s the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?
  8. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  9. A most vexing parse error: constructor with no arguments
  10. C++ Static member method call on class instance
  11. Why do const references extend the lifetime of rvalues?
  12. Why does C++ output negative numbers when using modulo?
  13. C/C++ int[] vs int* (pointers vs. array notation). What is the difference?
  14. Computing length of a C string at compile time. Is this really a constexpr?
  15. Is right shift undefined behavior if the count is larger than the width of the type?
  16. Is the order of iterating through std::map known (and guaranteed by the standard)?
  17. Why an unnamed namespace is a “superior” alternative to static? [duplicate]
  18. What are declarations and declarators and how are their types interpreted by the standard?
  19. When can you omit the file extension in an #include directive?
  20. Defining a variable in the condition part of an if-statement?
  21. Base pointer to array of derived objects
  22. Why statements cannot appear at namespace scope?
  23. Standard Library Containers with additional optional template parameters?
  24. Is it unspecified behavior to compare pointers to different arrays for equality?
  25. Is auto_ptr deprecated?
  26. Can I legally reinterpret_cast between layout-compatible standard-layout types?
  27. Is it legal/well-defined C++ to call a non-static method that doesn’t access members through a null pointer?
  28. Can we apply content not explicitly cited from the normative references to the C++ standard?
  29. Why must a std::ranges::filter_view object be non-const for querying its elements?
  30. is size_t always unsigned?

Leave a Comment