When a process completes its execution or is terminated prematurely, the kernel must release all system resources that were allocated to it. This includes files that were opened during the process's runtime, memory that was allocated, and other system-level resources. The following image illustrates this concept:
**Process Exit**
In Linux, a process can exit in two main ways: normally or abnormally.
**1. Normal Exit**
A process exits normally in the following scenarios:
- When the `main()` function returns.
- When the `exit()` function is called.
- When the `_exit()` function is used.
**2. Abnormal Exit**
An abnormal exit occurs when:
- A function like `abort()` is called.
- The process receives a signal that causes it to terminate unexpectedly.
Regardless of the exit method, the kernel eventually executes the same cleanup code. This code closes open file descriptors, releases memory, and frees up other resources that the process had been using.
**Comparison of Exit Methods**
**Difference between `exit()` and `return`**
The `exit()` function is a standard library function that takes parameters. Once called, it transfers control back to the operating system. On the other hand, `return` is used within a function to return control to the calling function. It does not terminate the entire program unless it's in the `main()` function.
**Difference between `exit()` and `abort()`**
`exit()` is a normal termination mechanism, whereas `abort()` is an abrupt, abnormal termination. `abort()` typically results in a core dump and is often used for debugging or error handling.
**`exit()` vs `_exit()` Functions**
Both `exit()` and `_exit()` are used to terminate a process. However, there are key differences:
- `exit()` is declared in ``, while `_exit()` is declared in ``.
- `exit()` performs some cleanup tasks before terminating the process, such as flushing buffers and calling functions registered with `atexit()`.
- `_exit()` immediately transfers control back to the kernel without performing these additional steps.
One of the most significant differences between `exit()` and `_exit()` lies in how they handle buffered I/O. The `exit()` function ensures that any data in the buffer is written to the file before the process terminates. In contrast, `_exit()` does not flush the buffer, which can lead to data loss if the process is terminated abruptly.
For example, consider the following two C programs:
**Example 1: `exit.c`**
```c
#include
#include
int main() {
printf("using exit----");
printf("This is the content in buffer");
exit(0);
}
```
**Output:**
```
using exit----
This is the content in buffer
```
**Example 2: `_exit.c`**
```c
#include
#include
int main() {
printf("using _exit--");
printf("This is the content in buffer");
_exit(0);
}
```
**Output:**
```
using _exit--
```
The reason for this difference is that `printf()` uses buffered I/O. The output is stored in a buffer and only flushed when a newline character is encountered or when the program exits normally via `exit()`. `_exit()` skips this step, leading to potential data loss.
**Parent and Child Process Termination Order**
The order in which a parent and child process terminate can have different consequences:
**1. Parent Exits Before Child**
If the parent process exits first, the child becomes an "orphan." The system will then assign the child to the `init` process, which will eventually clean it up.
**2. Child Exits Before Parent, No `wait()` Called**
If the child process terminates before the parent and the parent doesn’t call `wait()`, the child enters a "zombie" state. In this state, the process is no longer running but still occupies some system resources. The kernel keeps track of it until the parent calls `wait()` or the system reboots.
**3. Child Exits Before Parent, `wait()` Is Called**
If the parent calls `wait()` after the child has exited, the parent will wait for the child to finish and then release its resources. This prevents the creation of zombie processes.
A **zombie process** is one that has completed execution but has not yet been fully cleaned up by its parent. It remains in the process table until the parent retrieves its exit status. Zombie processes do not consume CPU or memory resources but can affect system performance if too many exist.
Touch Screen,Outdoor Touch Screen,Capactive-Touch,Multiple Points Touch
Shenzhen Risingstar Outdoor High Light LCD Co., Ltd , https://www.risingstarlcd.com