Linux：进程控制

目录

1：进程创建

 fork函数

写实拷贝

 fork常规用法

2：进程终止 

进程退出场景

进程常见退出方法

_exit函数

 exit函数

3：进程等待

 进程等待必要性

进程等待的方法

获取子进程status

 4：进程程序替换

替换原理 

 函数解释

命名理解

---

 进程：内核的相关管理数据结构(task_struct + mm_struct + 页表) + 代码和数据

1：进程创建

 fork函数

在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

 进程调用fork，当控制转移到内核中的fork代码后，内核做：

A：分配新的内存块和内核数据结构给子进程

B：将父进程部分数据结构内容拷贝至子进程

C：添加子进程到系统进程列表当中

D：fork返回，开始调度器调度

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但是他们得到的返回值fork的却是不一样的，进程ID的不同。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
int main(void)
{
    pid_t pid;
    printf("Before: pid is %d\n", getpid());
    if ((pid = fork()) == -1)
        perror("fork()"), exit(1);
    printf("After:pid is %d, fork return %d\n", getpid(), pid);
    sleep(1);
    return 0;
}

 这里看到了三行输出，一行before，两行after。进程43676先打印before消息，然后它有打印after。另一个after消息有43677打印的。注意到进程43677没有打印before。

 fork函数返回值

a: 子进程返回0

b: 父进程返回的是子进程的pid。

为什么返回两次？（之前的文章里有过解释）http://t.csdnimg.cn/5yecQhttp://t.csdnimg.cn/5yecQ

怎么理解进程具有独立性？

进程：

内核的相关管理数据结构(task_struct + mm_struct + 页表) + 代码（共享）和数据（写实拷贝）

写实拷贝

 通常，父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。

 fork常规用法

a：一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。

b：一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

 举个例子：

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

int main()
{
    pid_t pid = fork(); // 创建子进程

    if (pid < 0)
    {
        // fork失败
        perror("fork failed");
        exit(EXIT_FAILURE);
    }
    else if (pid == 0)
    {
        // 子进程
        printf("Child process, PID: %d, Parent PID: %d\n", getpid(), getppid());

        // 子进程执行新的程序，这里以"ls"命令为例
        // 使用execlp替换当前程序为"ls"，后面的参数将传递给"ls"
        execlp("ls", "ls", "-l", (char *)NULL);

        // 如果execlp成功，不会执行到这里，如果失败，则打印错误信息
        perror("execlp failed");
        _exit(EXIT_FAILURE);
    }
    else
    {
        // 父进程
        printf("Parent process, PID: %d, Child PID: %d\n", getpid(), pid);

        // 父进程在这里可以执行其他任务，例如等待客户端请求
        // 这里用pause()模拟父进程正在等待，直到被中断或子进程结束

        printf("Parent pause wait signal...\n");
        sleep(3);
        printf("Parent wait signal success! ! !\n");
        // 等待子进程结束
        int status;
        wait(&status); // 阻塞式等待
        printf("Child process ended with status: %d\n", status);
    }
    return 0;
}

fork调用失败的原因

 

2：进程终止 

进程退出场景

A：代码运行完毕

B：结果正确代码运行完毕

C：结果不正确代码异常终止

进程终止是在做什么？

1：释放属于自己的代码和数据所占的空间

2：释放内核数据结构(处理不好就会产生僵尸进程)

异常退出（程序出异常）：本质是因为进程收到了OS发给进程的信号！进程退出的时候，退出信号是多少我们就可以判断我们的进程为什么异常了！！！

进程常见退出方法

正常终止（可以通过 echo $? 查看进程退出码）：

1. 从main返回

2. 调用exit

3. _exit

异常退出：

ctrl + c，信号终止

_exit函数

#include <unistd.h>
void _exit(int status);

 参数：status 定义了进程的终止状态，父进程通过wait来获取该值

举个例子：

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

// 一个简单的退出处理程序，用于演示
void exit_handler(void) {
    printf("Exit handler called with status: %d\n", EXIT_SUCCESS);
}

int main() {
    // 注册退出处理程序
    atexit(exit_handler);

    pid_t pid = fork(); // 创建子进程

    if (pid < 0) {
        // fork失败
        perror("fork failed");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程使用_exit()立即退出
        printf("Child process using _exit() will exit now.\n");
        _exit(42); // 子进程立即终止，不会调用退出处理程序

        // 以下代码不会被执行
        printf("This will not be printed by the child using _exit().\n");
    } else {
        // 父进程等待子进程结束
        int status;
        pid_t terminated_pid = wait(&status);

        if (terminated_pid == -1) {
            perror("wait failed");
            exit(EXIT_FAILURE);
        }

        printf("\nChild process %d terminated.\n", terminated_pid);

        // 父进程继续执行
        printf("Parent process continues execution.\n");
    }

    // 父进程的其余代码...

    return 0;
}

 

说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值是255。

 exit函数

#include <unistd.h>
void exit(int status);

exit最后也会调用exit, 但在调用_exit之前，还做了其他工作：

1.  执行用户通过 atexit或on_exit定义的清理函数。

2.  关闭所有打开的流，所有的缓存数据均被写入

3.  调用_exit

int main()
{
    printf("hello");
    exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
hello[root@localhost linux]#

int main()
{
    printf("hello");
    _exit(0);
}
运行结果:
[root@localhost linux]# ./a.out
[root@localhost linux]#

return退出

return是一种更常见的退出进程方法。执行return n等同于执行exit(n),因为调用main的运行时函数会将main的返回值当做 exit的参数。

3：进程等待

 进程等待必要性

a：之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的 kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。

b：最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。

d：父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

进程等待的方法

wait方法 

#include<sys/types.h>
#include<sys/wait.h>

pid_t wait(int*status);

返回值：
    成功返回被等待进程pid，失败返回-1。
参数：
    输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

waitpid方法

pid_ t waitpid(pid_t pid, int *status, int options);
返回值：
    当正常返回的时候waitpid返回收集到的子进程的进程ID；
    如果设置了选项WNOHANG（非阻塞）,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
    如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；
参数：
    pid：
        Pid=-1,等待任一个子进程。与wait等效。
        Pid>0.等待其进程ID与pid相等的子进程。
    status:
        WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
        WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
    options:
        WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

a：如果子进程已经退出，调用 wait / waitpid 时，wait / waitpid会立即返回，并且释放资源，获得子进程退出信息。

b：如果在任意时刻调用wait / waitpid，子进程存在且正常运行，则进程可能阻塞。

c：如果不存在该子进程，则立即出错返回。

阻塞等待  or 非阻塞等待 + 循环 == 非阻塞轮询

获取子进程status

a：wait 和 waitpid，都有一个 status 参数，该参数是一个输出型参数，由操作系统填充。

b：如果传递NULL，表示不关心子进程的退出状态信息。

c：否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

d：status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）：

1. 程序终止状态：通常在UNIX-like系统中，当一个程序终止时，它会返回一个状态码给其父进程或shell。这个状态码可以表明程序是如何终止的。

2. 正常终止：程序成功执行完毕，返回状态码0。

3. 退出状态：程序通过调用exit()函数或返回从main()函数的值来正常退出，其退出状态码可以是除了0之外的任何值，用于表示程序的退出状态。

4. 被信号所杀：程序因为接收到某个信号而终止。在这种情况下，状态码的高位字节会被设置为0x80，低位字节表示信号的编号。

5. 未用：这部分状态码未被使用。

6. 终止信号：如果程序因为接收到信号而终止，状态码的低位字节将表示该信号的编号。

7. core dump标志：当程序因为接收到某些信号（通常是致命信号）而终止时，如果设置了核心转储标志，操作系统会将程序的内存映像写入到一个核心转储文件中，以便于后续的调试和分析。core是核心转储文件的缩写。

8. 示例状态码：图片中提到了两个数字15和8 7。这可能表示状态码的值。例如，15可能是SIGTERM（终止信号）的编号，而8 7可能表示程序因为接收到信号7而终止，并且设置了核心转储标志（因为8是1000的二进制表示，最高位是1，表示设置了核心转储标志）。

核心转储（core dump）

核心转储是进程的内存映像，当进程因为某些致命错误（如违反访问权限）而终止时，操作系统可能会将这个内存映像写入到一个文件中，以便于后续的分析和调试。在子进程的退出状态中，核心转储的标志位通常表示该进程是因为接收到了某些信号而终止的。

举个例子：

 4：进程程序替换

替换原理 

 用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

1：int execl(const char *path, const char *arg, ...);

    execl：函数用于执行一个新的程序。
    path：参数指定要执行的程序的路径。
    arg：是传递给新程序的第一个参数（相当于命令行的第一个参数）。
    随后的参数以可变参数列表（...）的形式提供，以空指针NULL结束。
    这个函数不返回，除非发生错误。

2：int execlp(const char *file, const char *arg, ...);

    execlp：函数类似于execl，但它在环境变量PATH指定的路径中搜索程序。
    file:是程序的名称，不需要路径前缀。
    其余参数与execl相同。

3：int execle(const char *path, const char *arg, ..., char *const envp[]);

    execle：函数执行新程序，并且允许指定环境变量。
    path：是要执行的程序的路径。
    arg：是传递给新程序的第一个参数。
         随后的参数以可变参数列表的形式提供，以空指针NULL结束。
    envp：是指向环境变量数组的指针，定义了新程序的环境。

4：int execv(const char *path, char *const argv[]);

    execv：函数执行新程序。
    path：是要执行的程序的路径。
    argv：是一个数组，包含了传递给新程序的参数列表，以空指针NULL结束。

5：int execvp(const char *file, char *const argv[]);

    execvp：函数类似于execv，但它在环境变量PATH中搜索程序。
    file：是程序的名称。
    argv：是参数数组。

6：int execve(const char *path, char *const argv[], char *const envp[]);

    execve：函数执行新程序，并且允许指定环境变量。
    path：是要执行的程序的路径。
    argv：是参数数组。
    envp：是指向环境变量数组的指针。

 函数解释

• 当exec系列函数（如execl、execv、execle等）调用成功时，它们会替换当前进程的映像为新的程序，并从头开始执行新程序的代码。这意味着，一旦exec函数成功执行，当前的程序上下文将不复存在，控制权转移到新程序的入口点（通常是main()函数）。

• 如果exec系列函数调用失败，它们会返回-1，并设置全局变量errno来指示错误的原因。错误可能由多种原因引起，如文件找不到、权限不足、无效的参数等。

由于exec函数在成功时会完全替换当前进程的映像，因此它们不会返回任何值来表示成功。它们的返回语句仅用于错误情况的处理。这也是为什么exec系列函数没有成功返回值的原因。

命名理解

 b：l(list) : 表示参数采用列表

c：v(vector) : 参数用数组

d：p(path) : 有p自动搜索环境变量PATH

e：e(env) : 表示自己维护环境变量

事实上,只有execve是真正的系统调用,其它五个函数最终都调用 execve。