Methodology: Understand the exit method of Linux process

Introduction

When a process ends or terminates midway, the kernel needs to release the system resources occupied by the process. This includes files opened while the process is running, memory requested, etc.

Process exit

The exit of a process under Linux is divided into two types: normal exit and abnormal exit:

1.Exit normally

a. Execute return in the main() function.

b. Call the exit() function

c. Call the _exit() function

2.Exit abnormally

a. Call about function

b. The process receives a signal, and the signal causes the program to terminate.

No matter which exit method is used, the system will eventually execute the same code in the kernel. This code is used to close the open file descriptor used by the process and release the memory and other resources it occupies.

Comparison of several exit methods

1. The difference between exit and return:

exit is a function with parameters. After exit is executed, control is handed over to the system

return is the return after the function is executed. After renturn is executed, control is handed over to the calling function.

2. The difference between exit and abort:

exit is the normal termination of the process

about is abnormal termination.

exit() and _exit() functions

The exit and _exit functions are both used to terminate the process. When the program executes exit or _exit, the system unconditionally stops all remaining operations, clears various data structures, and terminates the running of the process.

exit is declared in the header file stdlib.h, and _exit() is declared in the header file unistd.h. The parameter exit_code in exit is 0, which means that the process terminates normally. If it is other values, it means that an error occurs during program execution.

The difference between exit() and _exit()

_exit() returns to the kernel immediately after execution, while exit() must first perform some clearing operations and then transfer control to the kernel.

When the _exit function is called, it will close all file descriptors of the process, clean up the memory and some other kernel cleaning functions, but will not refresh the stream (stdin, stdout, stderr...). The exit function is in _exit A wrapper over a function that calls _exit and flushes the stream before calling it.

The biggest difference between the exit() function and the _exit() function is that the exit() function checks the open status of the file and writes the contents of the file buffer back to the file before calling the exit system. Because there is an operation called "buffered I/O" in the Linux standard function library, its characteristic is that there is a buffer in the memory corresponding to each open file. Each time a file is read, several records will be read continuously, so that the next time the file is read, it can be read directly from the memory buffer; similarly, every time a file is written, it is only written to the memory buffer. When certain conditions are met (such as reaching a certain number or encountering specific characters, etc.), the contents in the buffer are written to the file at once. This technology greatly increases the speed of file reading and writing, but it also brings a little trouble to programming. For example, there is some data that is thought to have been written to the file. In fact, because it does not meet specific conditions, it is only saved in the buffer. At this time, use the _exit() function to directly close the process, and the data in the buffer will be lost. . Therefore, if you want to ensure the integrity of the data, you must use the exit() function.

Let’s look at the difference between them through a function example:

Function example 1: exit.c

#include
#include

int main()
{
printf("using exit----\n");
printf("This is the content in buffer\n");
exit(0);
}

The execution result is:

using exit----

This is the content in buffer

Function example 2: _exit.c

#include
#include

int main()
{
printf("using _exit--\n");
printf("This is the content in buffer");
_exit(0);
}

The execution result is:

using _exit--

The printf function uses buffered I/O. This function automatically reads the record from the buffer when encountering the "\n" newline character. Therefore, exit() exits after writing the data in the buffer, while the _exit() function exits directly.

You can also change printf("This is the content in buffer"); in function instance 2 to printf("This is the content in buffer\n") (that is, add a \n at the end of printf to see What is the running result and why does it produce such a result?)

The different order of termination of the parent and child processes will produce different results

1. The parent process terminates before the child process:

This situation is the orphan process we used earlier. When the parent process exits first, the system will let the init process take over the child process.

2. The child process terminates before the parent process, but the parent process does not call the wait function

In this case, the child process enters a zombie state and will remain so until the system is restarted. When the child process is in a zombie state, the kernel only saves some necessary information about the process for the parent process. At this time, the child process always occupies resources, and it also reduces the maximum number of processes that the system can create.

What is the zombie state?

A process that has terminated but whose parent process has not yet dealt with it (obtaining information about the terminated child process and releasing the resources it still occupies) is called a zombie process (zombie).

3. The child process terminates before the parent process, and the parent process calls the wait function

At this time the parent process will wait for the child process to end.

The above is the detailed content of Methodology: Understand the exit method of Linux process. For more information, please follow other related articles on the PHP Chinese website!