How to end a process under Linux: Detailed explanation of normal and abnormal termination

In the first two chapters, we learned about creating processes. In this chapter, we will learn how to end the process under Linux.

In Linux, there are 3 ways to end a process normally and 2 ways to terminate abnormally:

1. Normal end:

a. Call return in the main function. This is equivalent to calling exit.

b. Call the exit function. According to the definition of this function in ANSIC, when called, all registered exit handles will be executed, all standard I/O streams will be turned off, and file descriptors and multiple processes (parent processes) will not be processed. (with child processes), jobs, etc., so it is not sound for Linux systems.

c. Call the _exit function. Exit is called linux training by _exit and closes some linux-specific exit handles.

2. Abnormal termination

a. Call abort. This seems to be a special case of the second case, since it forms a SIGABRT signal.

b. The process receives a specific signal. This signal can be generated by the process itself (such as the abort function), or it can come from other processes or the kernel. For example: when a process attempts to access an out-of-bounds memory address or when the divisor is zero, the kernel will generate a signal to interrupt the process.

No matter which method is used to end the process, the same piece of code in the kernel will eventually be executed. This code closes all file descriptors opened by the process, the video memory occupied by private access, etc.

Let’s take a look at the exit and _exit functions

These two functions are in different header files: exit is in stdlib.h, _exit is in unistd.h

Their specific calling methods are as follows:

voidexit(int__status)

void_exit(int__status)

The status parameter is the exit status.

Let’s take a look at the following two pieces of code:

Picture 1

Picture 2

Picture 3

Picture 4

The code in Figure 1 lacks n, resulting in the sentence at the end of the test not being copied. This is because if printf does not add n, the information will not be copied immediately, and _exit will not force the output of the data in the buffer. , that is, the data that has not been written to the device and is still in the buffer caused by calls such as printf/fprintf will be discarded. The copy information will be lost during _exit, but not with exit. If there is n, copy it directly. At this time, there is no difference between exit/_exit

The different order in which the brother and sister processes are terminated will produce different results

1. The parent process terminates before the child process:

This situation is what we call an orphan process. 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, and the parent process does not call the wait function

In this case, the sub-process enters a zombie state and will remain so until the system is restarted. When the child process is in a zombie state Under Linux, it exits without saving. The kernel only saves some necessary information of the process for the parent process. At this time, the child process still occupies resources, and it also reduces the maximum number of processes that can be created by the system.

What are the zombie states?

A process that has been terminated long ago, but its parent process has not yet dealt with the aftermath (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 processExits without saving under Linux, but 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 How to end a process under Linux: Detailed explanation of normal and abnormal termination. For more information, please follow other related articles on the PHP Chinese website!