Linux进程（四） --- 终止和等待

yyl0327

已于 2024-05-19 05:15:09 修改

阅读量639

点赞数 17

文章标签： linux 运维服务器 c++ c语言

于 2024-05-19 05:13:10 首次发布

本文链接：https://blog.csdn.net/yyl0327/article/details/139034539

版权

main函数的返回值

在C和C++编程语言中，main函数是程序的入口点，当程序启动时，操作系统会调用这个函数。main函数的返回值具有特定的含义和作用。

`main`函数的返回值含义

main函数的返回值类型通常是int，它用于向操作系统或调用它的程序指示程序的终止状态。这个返回值被称为退出状态码（exit status code）。以下是关于main函数返回值的一些重要概念：

1. 表示程序的执行结果

返回值0：通常表示程序成功执行并正常退出。它是约定俗成的标准，表示没有发生错误。
非零返回值：表示程序遇到了错误或异常情况。不同的非零值可以表示不同类型的错误，具体的含义通常由程序员定义。

2. 向调用者传递信息

操作系统或脚本可以根据main函数的返回值决定后续操作。例如，在shell脚本中，可以使用$?来获取上一个命令的退出状态，并根据这个状态执行不同的操作。

`return`语句的作用

1. 终止程序

return语句会终止main函数的执行，并将控制权返回给操作系统或调用它的程序。程序的执行到此结束。

2. 传递退出状态

return语句将一个整数值作为退出状态返回给操作系统或调用它的程序。这个整数值就是main函数的返回值。

示例代码

#include <stdio.h>

int main() {
    printf("Hello, world!\n");
    return 0; // 返回0，表示程序成功执行
}

在这个示例中，main函数打印一行文本后返回0，表示程序成功执行并正常退出。

使用`exit`函数

除了直接使用return语句，程序还可以调用标准库函数exit来终止程序，并返回退出状态。

#include <stdio.h>
#include <stdlib.h>

int main() {
    printf("Hello, world!\n");
    exit(0); // 返回0，表示程序成功执行
}

使用exit函数可以更灵活地终止程序，并确保所有打开的文件和其他资源都能正确关闭和释放。

非零返回值的使用示例

非零返回值通常用于表示错误或异常情况。例如：

#include <stdio.h>

int main() {
    if (some_error_condition) {
        return 1; // 返回1，表示程序遇到错误
    }
    
    printf("Hello, world!\n");
    return 0; // 返回0，表示程序成功执行
}

在这个示例中，如果某个错误条件为真，程序将返回1，表示遇到错误。否则，程序正常执行并返回0。

操作系统对返回值的处理

不同的操作系统可能对退出状态码有不同的处理方式，但通常的约定如下：

POSIX系统（如Linux、Unix）：退出状态码是一个8位无符号整数（0-255）。return 0表示成功，return 1-255表示不同类型的错误。
Windows系统：退出状态码也通常是0表示成功，非零表示错误。

信号

什么是信号？

信号是一种异步通知机制，用于通知进程某个事件已经发生。信号可以来自操作系统、硬件、用户或其他进程。

信号的用途

进程间通信：进程可以通过发送信号来通知其他进程特定的事件。
异常处理：操作系统可以发送信号来通知进程某些异常情况（如除零错误、非法内存访问）。
控制进程：用户可以通过命令行工具（如kill命令）发送信号来控制进程的执行（如终止、暂停、继续）。

常见信号

SIGINT：中断信号，通常由用户按Ctrl+C发送，用于终止进程。
SIGTERM：终止信号，用于请求正常终止进程。
SIGKILL：强制终止信号，无法被捕获或忽略，用于强制终止进程。
SIGSEGV：段错误信号，当进程非法访问内存时发送。

信号处理

进程可以通过注册信号处理程序（signal handler）来捕获和处理特定信号。例如：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>

// 信号处理程序
void handle_signal(int signal) {
    printf("Caught signal %d\n", signal);
}

int main() {
    // 注册SIGINT的信号处理程序
    signal(SIGINT, handle_signal);
    
    // 无限循环，等待信号
    while (1) {
        printf("Running...\n");
        sleep(1);
    }
    return 0;
}

退出码和信号的结合

退出码（Exit Code）

作用和用途

表示程序的执行结果

退出码是程序在终止时返回给操作系统的一个整数值，用于表示程序的执行结果。

通常，返回值0表示程序成功执行，非零值表示程序遇到了某种错误或异常。

进程间通信

父进程或调用脚本可以通过检查子进程的退出码来了解其执行状态，从而决定接下来的操作。

在Unix/Linux系统中，shell脚本通常使用特殊变量$?来获取上一条命令的退出码。

信号（Signal）

作用和用途

异步通知

信号是一种异步通知机制，用于通知进程某个事件的发生。信号可以来自操作系统、硬件、用户或其他进程。

信号可以在进程执行的任意时刻触发，这使得它们适用于处理异步事件，如外部中断、非法内存访问等。

进程控制

信号可以用于控制进程的执行，如终止、暂停、继续运行等。

用户可以通过命令行工具（如kill命令）向进程发送信号，操作系统也可以在特定条件下自动发送信号。

为什么需要同时存在退出码和信号？

不同的使用场景

退出码的使用场景
- 退出码主要用于进程终止时传递状态信息。它适用于进程执行完毕后的状态传递，通常用于批处理、脚本、以及父子进程间的简单状态传递。
- 退出码只能在进程结束时使用，并且是单向的（从子进程到父进程）。
信号的使用场景
- 信号适用于异步事件处理和进程控制。它们可以在进程执行的任何时刻发送和处理，适用于处理实时事件，如用户中断、定时器、外部硬件中断等。
- 信号可以在进程的整个生命周期内使用，并且可以双向传递（进程间互相发送信号）。

互补作用

异步与同步
- 信号提供异步通知机制，能够在进程运行过程中随时处理紧急事件。
- 退出码提供同步状态传递机制，能够在进程结束时传递执行结果。
控制与状态
- 信号可以直接控制进程的执行状态，如终止、暂停、继续等，这在进程控制和异常处理上非常重要。
- 退出码则用于传递进程的最终状态，这在任务完成后的结果报告上非常重要。

进程的退出步骤

进程在退出时需要执行一系列步骤来确保资源的正确释放和系统状态的维护。这些步骤包括从用户态到内核态的转换、文件描述符和内存的清理、进程控制块的更新等。以下是进程退出的详细步骤：

1. 进程发起退出请求

进程退出通常由以下几种情况触发：

程序正常结束：通过return从main函数返回，或调用exit函数。
程序异常结束：由于未捕获的异常或错误，如段错误（Segmentation Fault）。
外部信号：接收到终止信号（如SIGTERM或SIGKILL）。

2. 调用`exit`函数

当进程发起退出请求时，通常会调用标准库中的exit函数。exit函数的主要任务是：

调用所有注册的退出处理程序（通过atexit函数注册）。
调用所有打开的文件流（如stdout、stderr）的清理函数，确保缓冲区中的数据被正确刷新到文件或终端。

3. 执行退出处理程序

如果进程注册了退出处理程序（通过atexit函数），这些处理程序会在进程退出时被依次调用。处理程序可以执行一些清理操作，如释放动态分配的内存、关闭打开的文件等。

4. 从用户态转换到内核态

进程通过系统调用_exit（由exit函数内部调用）进入内核态。_exit是一个更底层的系统调用，它不会执行标准C库的清理操作，直接进入内核态执行后续的进程退出步骤。

5. 关闭文件描述符

内核为进程打开的所有文件描述符会被关闭。文件描述符对应的文件、管道、网络连接等资源将被释放。如果其他进程仍在使用这些资源，引用计数会减少，但不会完全释放。

6. 释放内存

内核会释放进程占用的所有内存，包括：

用户栈和内核栈。
动态分配的堆内存。
代码段和数据段。
内存映射区域。

7. 释放进程控制块（PCB）

进程控制块（PCB）是内核中用于管理进程的关键数据结构，包含了进程的状态、寄存器上下文、文件描述符列表等信息。在进程退出时，内核会从进程表中移除对应的PCB，并将其资源释放或重新分配。

8. 通知父进程

内核会将退出的进程标记为“僵尸进程”（Zombie Process），并向其父进程发送SIGCHLD信号，通知父进程子进程已经退出。父进程可以通过调用wait或waitpid函数获取子进程的退出状态，并清理僵尸进程。

9. 更新进程状态

内核会更新进程的状态，将其从运行态或睡眠态转移到终止态，并从运行队列中移除。这包括从调度器的数据结构中删除进程条目。

10. 释放资源

内核会释放进程持有的其他所有资源，如IPC资源（消息队列、信号量、共享内存）、锁、信号处理函数等。

11. 最终清理

在所有清理操作完成后，进程的内存空间和其他资源将被完全释放，进程彻底终止。

进程的等待

进程的等待是指一个进程在执行过程中暂停其操作，等待某个特定事件的发生或者等待其他进程的执行结果。进程等待主要用于进程同步和资源管理，确保多个进程之间的协同工作和资源的正确使用。下面详细解释进程等待的概念、用途以及常见的等待机制。

进程等待的用途

进程同步：
- 当多个进程需要协调工作时，进程等待机制可以确保一个进程在某个条件满足前暂停执行，以便其他进程能够完成其任务。这对于确保数据一致性和避免竞态条件非常重要。
资源管理：
- 当一个进程需要访问某个资源（如文件、内存块、设备等）但该资源当前不可用时，它可以进入等待状态，直到资源变得可用。这样可以防止资源争用和死锁。
进程终止的处理：
- 父进程需要等待子进程的结束，以获取子进程的退出状态并清理其资源。这可以避免出现僵尸进程。

进程等待的常见机制

1. `wait` 和 `waitpid`

这些是Unix和Linux系统中用于等待子进程结束的系统调用。

wait：
- 等待任一子进程结束。如果有多个子进程，wait会挂起调用进程直到任一子进程结束。
- pid_t wait(int *status);
- status 参数用来存储子进程的退出状态。
waitpid：
- 更灵活的等待子进程结束的系统调用。可以指定等待的子进程ID，还可以设置选项控制等待行为。
- pid_t waitpid(pid_t pid, int *status, int options);
- pid 参数可以指定特定的子进程ID，status 存储退出状态，options 可以设置为 WNOHANG（非阻塞模式）。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid < 0) {
        perror("fork failed");
        exit(1);
    } else if (pid == 0) {
        // 子进程
        printf("Child process running...\n");
        sleep(2); // 模拟子进程工作
        printf("Child process exiting...\n");
        exit(42); // 子进程退出码
    } else {
        // 父进程
        int status;
        pid_t child_pid = wait(&status); // 等待子进程结束
        if (WIFEXITED(status)) {
            printf("Child process %d exited with status %d\n", child_pid, WEXITSTATUS(status));
        }
    }

    return 0;
}

进程等待的状态

在操作系统中，进程在等待某个事件发生时会进入特定的等待状态。这些状态包括：

阻塞（Blocked）：
- 进程正在等待某个事件（如I/O完成、信号量释放等）发生，此时进程无法继续执行，CPU资源可以分配给其他进程。
睡眠（Sleeping）：
- 进程被挂起，等待某个条件满足，如特定的时间间隔过去（定时器）、资源可用等。
僵尸（Zombie）：
- 进程已经结束执行，但其退出状态尚未被父进程获取。僵尸进程仍然占据PCB条目，等待父进程的wait或waitpid调用。

父进程等待子进程

1. 获取子进程的退出状态

当一个子进程终止时，操作系统会保留子进程的退出状态，以便父进程可以获取这个状态。这种状态包括子进程的退出码，以及子进程是否因为信号终止。如果父进程不显式地等待子进程，这些状态信息将一直保留，导致子进程进入僵尸状态，占用系统资源。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        // 子进程
        printf("Child process running...\n");
        sleep(2);
        printf("Child process exiting...\n");
        exit(42);
    } else {
        // 父进程
        int status;
        pid_t child_pid = wait(&status); // 等待子进程结束
        if (WIFEXITED(status)) {
            printf("Child process %d exited with status %d\n", child_pid, WEXITSTATUS(status));
        } else if (WIFSIGNALED(status)) {
            printf("Child process %d was terminated by signal %d\n", child_pid, WTERMSIG(status));
        }
    }

    return 0;
}

2. 防止僵尸进程

僵尸进程（Zombie Process）是指已经终止但其退出状态未被父进程获取的子进程。僵尸进程保留在系统中，占用进程表条目。如果父进程不等待子进程并获取其退出状态，这些僵尸进程将累积，最终可能耗尽系统的进程表条目，导致系统无法创建新进程。

通过调用wait或waitpid函数，父进程可以读取子进程的退出状态并清理其资源，从而防止僵尸进程。

3. 同步进程执行

在某些情况下，父进程需要等待子进程完成某些任务，然后才能继续执行后续操作。通过等待子进程，父进程可以确保子进程已经完成必要的工作，如初始化资源、执行计算等，然后再继续执行。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        // 子进程
        printf("Child process initializing...\n");
        sleep(2); // 模拟初始化工作
        printf("Child process done initializing.\n");
        exit(0);
    } else {
        // 父进程
        wait(NULL); // 等待子进程完成
        printf("Parent process continuing after child process.\n");
        // 执行后续操作
    }

    return 0;
}

4. 资源回收

子进程终止后，操作系统会保留其资源，直到父进程调用wait或waitpid获取子进程的退出状态。这包括子进程的进程表条目、内存资源等。父进程等待子进程的退出状态是回收这些资源的必要步骤，确保系统资源得到正确管理和释放。

5. 处理多子进程

在复杂的应用程序中，父进程可能会创建多个子进程来执行并行任务。通过waitpid函数，父进程可以灵活地等待特定的子进程或所有子进程完成，确保所有任务都已完成，然后再进行下一步操作。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

#define NUM_CHILDREN 3

int main() {
    pid_t pids[NUM_CHILDREN];

    // 创建多个子进程
    for (int i = 0; i < NUM_CHILDREN; i++) {
        pids[i] = fork();
        if (pids[i] == 0) {
            // 子进程
            printf("Child %d process running...\n", i);
            sleep(i + 1); // 模拟不同的工作时间
            printf("Child %d process exiting...\n", i);
            exit(0);
        }
    }

    // 等待所有子进程结束
    for (int i = 0; i < NUM_CHILDREN; i++) {
        waitpid(pids[i], NULL, 0);
    }

    printf("All child processes have exited. Parent process continuing.\n");

    return 0;
}