Linux系统编程---进程(二)

菜就多练wwww

已于 2024-04-28 20:14:34 修改

阅读量1.2k

点赞数 41

分类专栏： Linux系统编程文章标签： linux 运维服务器

于 2024-04-17 10:19:56 首次发布

本文链接：https://blog.csdn.net/qq_51647149/article/details/137853984

版权

Linux系统编程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、进程替换：exec函数族

fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id和其他系统资源（如文件描述符、信号处理程序等）并未改变。

exec函数族：使进程执行某一程序。成功无返回值，失败返回 -1。

其实有六种以exec开头的函数，统称exec函数：

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

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

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

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

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

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

l (list)                           命令行参数列表

p (path)                       搜素file时使用path变量

v (vector)                    使用命令行参数数组

e (environment)       使用环境变量数组,不使用进程原有的环境变量，设置新加载程序运行的环境变量

execl函数：

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

参数

path: 要执行的程序的完整路径。
arg: 执行程序时传递的第一个参数(从argv[0]开始调用)，通常是程序的名称。随后可以跟随任意多个参数字符串，最后必须以 NULL(哨兵) 结尾来标示参数列表的结束。

返回值

如果 execl 函数执行成功，它不会返回值，因为当前进程的执行已被新程序完全替代。
如果有错误发生，它将返回 -1 并设置 errno

execlp函数：

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

execlp 函数与 execl 类似，但它会使用系统的环境变量 PATH 来查找可执行文件，因此只需提供程序的名称而不是完整路径。

参数

file: 要执行的程序的名称。如果包含了路径，则按路径执行；如果没有路径，则在 PATH 环境变量指定的目录中查找。
arg: 执行程序时传递的第一个参数(从argv[0]开始调用)，通常是程序的名称。随后可以跟随任意多个参数字符串，最后必须以 NULL(哨兵) 结尾来标示参数列表的结束。

返回值

如果 execlp 函数执行成功，它不会返回值，因为当前进程的执行已被新程序完全替代。
如果有错误发生，它将返回 -1 并设置 errno。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>

int main(int argc,char *argv[])
{
        pid_t pid = fork();     //创建子进程
        if (pid == -1){
                perror("fork error");
                exit(1);

        }else if(pid == 0){     //子进程
                //execlp("ls","-l","-d","-h",NULL);错误写法
        //      execlp("ls","ls","-l","-h",NULL);
        //      execlp("date","date",NULL);
        
        //      execl("./a.out","./a.out",NULL);
        //      execl("/bin/ls","ls","-l",NULL);
        //      execl("/usr/bin/ls","/usr/bin/ls","-l","-h",NULL);
                char *argv[] = {"ls","-l","-h",NULL};
                execvp("ls",argv);
                
                perror("exec error");
                exit(1);

        }else if(pid > 0){      //父进程
                sleep(1);
                printf("I'm parent:%d\n",getpid());
        }


        return 0;
}

执行程序即执行ls -lh命令，列出当前目录下的所有文件

练习：写一个程序，使用execlp执行进程查看，并将当前系统中的进程信息打印到文件中

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

int main(void)
{
        int fd;

        fd = open("ps.out",O_WRONLY|O_CREAT|O_TRUNC,0644);
        if(fd<0){
                perror("open ps.out error");
                exit(1);
        }

        dup2(fd,STDOUT_FILENO);

        execlp("ps","ps","aux",NULL);
        perror("execlp error");

        //close(fd);
        
        return 0;
}

执行程序，会将命令ps aux执行出的结果打印到ps.out文件中

exec函数族一般规律：

exec函数一旦调用成功，即执行新的程序，不返回。
只有失败才返回，错误值-1，所以通常我们直接在exec函数调用后直接调用perror()和exit()，无需if判断。

二、孤儿进程和僵尸进程

孤儿进程：

父进程先于子进终止，子进程沦为“孤儿进程”，这些子进程的父进程会被自动设置为 init 进程（在大多数Unix系统中是进程号为1的进程）。init 进程(孤儿院)将定期执行 wait() 调用以收集其子进程的状态，这样子进程就不会变成僵尸进程

僵尸进程：

子进程终止，父进程尚未对子进程进行回收，在此期间，子进程为“僵尸进程”。 kill 对其无效。这里要注意，每个进程结束后都必然会经历僵尸态，时间长短的差别而已。
子进程终止时，子进程残留资源PCB存放于内核中，PCB记录了进程结束原因，进程回收就是回收PCB。回收僵尸进程，得kill它的父进程，让孤儿院去回收它。

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

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

    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid > 0) {
        // 父进程
        printf("Parent process, pid = %d\n", getpid());
        sleep(10);  // 让父进程先睡眠一会儿，使子进程有机会运行
        printf("Parent process exit\n");
    } else {
        // 子进程
        printf("Child process, pid = %d\n", getpid());
        sleep(20);  // 子进程继续运行，即使父进程已经退出
        printf("Child process exit\n");
    }

    return 0;
}

三、等待子进程退出并回收函数

在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件、占用的内存等。但是仍然为其保留了一定的信息，这些信息主要是指进程控制块PCB的信息(包括进程号、退出状态、运行时间等)。

父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。

wait()和waitpid()的功能一样，区别在于wait()会阻塞（如果子进程没结束，那么就一直等待不做其他事），waitpid()可以设置不阻塞，waitpid()还可以指定等待哪个子进程结束

注意：一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环

1.wait函数

pid_t wait(int *status);

回收子进程退出资源，阻塞回收任意一个。

参数

status: （传出）回收进程的状态。指向一个整数的指针，用来存储子进程退出时的状态信息。可以通过这个参数获得子进程的退出原因，例如正常退出、错误退出或被信号终止。

返回值

成功: 回收进程的pid
失败: -1， errno

函数作用

阻塞等待子进程退出
清理子进程残留在内核的 pcb 资源
通过传出参数，得到子进程结束状态

2.waitpid函数

pid_t waitpid(pid_t pid, int *status, int options);

指定某一个进程进行回收。可以设置非阻塞。

参数

pid:指定回收某一个子进程pid
如果 pid > 0，待回收的子进程pid。
如果 pid == 0，同组的子进程。
如果 pid < -1，等待其进程组 ID 等于 pid 绝对值的子进程。
如果 pid == -1，任意子进程，等同于 wait()。waitpid(-1，&status,0)== wait(&status).
status: 同 wait。
options: 控制 waitpid 的行为，常用的选项包括：
WNOHANG: 指定回收方式为不(非)阻塞。
WUNTRACED: 除了返回终止子进程的信息外，还返回因信号停止的子进程信息。

返回值

>0：表成功回收的子进程 pid
0：函数调用时，参3 指定了WNOHANG，并且没有子进程结束。
-1：失败，errno

wait 和 waitpid 函数的示例：

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

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

    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid > 0) {
        // 父进程
        int status;
        // 使用 wait
        // pid_t child_pid = wait(&status);

        // 使用 waitpid
        pid_t child_pid = waitpid(pid, &status, 0); // 等待特定的子进程

        if (child_pid == -1) {
            perror("wait");
        } else if (WIFEXITED(status)) {
            printf("Child %d finished with status %d\n", child_pid, WEXITSTATUS(status));
        }
    } else {
        // 子进程
        printf("Child process\n");
        sleep(2); // 假装正在做一些工作
        exit(5);
    }

    return 0;
}

父进程创建一个子进程并使用 waitpid 等待这个特定子进程结束。可以将 waitpid 调用的参数更改为使用 wait，以等待任何子进程结束。

3.获取子进程退出值和异常终止信号

一个进程终止时会关闭所有文件描述符，释放在用户空间分配的内存，但它的PCB还保留着，内核在其中保存了一些信息：如果是正常终止则保存着退出状态，如果是异常终止则保存着导致该进程终止的信号是哪个。
这个进程的父进程可以调用wait或者waitpid获取这些信息，然后彻底清除掉这个进程。
一个进程的退出状态可以在shell中用特殊变量$？查看，因为shell是它的父进程，当它终止时，shell调用wait或者waitpid得到它的退出状态，同时彻底清除掉这个进程。

获取子进程正常终止值：

WIFEXITED(status) --> 为真 -->调用 WEXITSTATUS(status) --> 得到子进程退出值。

获取导致子进程异常终止信号：

WIFSIGNALED(status) --> 为真 -->调用 WTERMSIG(status) --> 得到导致子进程异常终止的信号编号

捕获程序异常终止的信号并打印(wait阻塞回收)：

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

int main(void)  
{  
    pid_t pid, wpid;  
    int status;  
  
    pid = fork();  
    if (pid == 0) {  
        printf("---child, my id= %d, going to sleep 10s\n", getpid());  
        sleep(10);  
        printf("-------------child die--------------\n");  
        return 73;  
    } else if (pid > 0) {  
        //wpid = wait(NULL);          // 不关心子进程结束原因  
        wpid = wait(&status);       // 如果子进程未终止,父进程阻塞在这个函数上  
        if (wpid == -1) {  
            perror("wait error");  
            exit(1);  
        }  
        if (WIFEXITED(status)) {        //为真,说明子进程正常终止.   
            printf("child exit with %d\n", WEXITSTATUS(status));  
  
        }  
        if (WIFSIGNALED(status)) {      //为真,说明子进程是被信号终止.  
  
            printf("child kill with signal %d\n", WTERMSIG(status));  
        }  
  
        printf("------------parent wait finish: %d\n", wpid);  
    } else {  
        perror("fork");  
        return 1;  
    }  
  
    return 0;  
}

指定回收第三个进程两种实现

一个是阻塞等待回收指定进程，一个是非阻塞，但是用sleep延时父进程，以保证待回收的指定子进程已经执行结束。上面这个代码使用的阻塞回收，这个方案的问题在于终端提示符会和输出混杂在一起。
下面使用非阻塞回收+延时的方法，这样终端提示符就不会混在输出里。

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

int main(int argc,char *argv[])
{
        int i;
        pid_t pid,wpid,tmpid;

        for (i = 0;i < 5;i++){
                pid = fork();   
                if (pid == 0){//循环期间子进程不fork
                        break;
                }
                if (i == 2){
                        tmpid = pid;
                        printf("-----pid= %d\n",tmpid);
                }
        }
                if (5 == i){    //父进程从表达式2跳出
                sleep(5);

        //      wait(NULL);//一次wait/waitpid函数调用，只能回收一个子进程  
        //      wpid = waitpid(-1,NULL,WNOHANG);//回收任意子进程，没有结束的子进程，父进程直接返回0
        //      wpid = waitpid(tmpid,NULL,0);//指定一个进程回收，阻塞回收

                printf("----I am parent,before waitpid,pid = %d\n",tmpid);
                wpid = waitpid(tmpid,NULL,WNOHANG);//①指定一个进程回收，不阻塞
        //      wpid = waitpid(tmpid,NULL,0);//②指定一个进程回收，阻塞回收，注释sleep(5)
                if (wpid == -1){
                        perror("waitpid error");
                        exit(1);
                }
                printf("I'm parent,wait a child finish:%d\n",wpid);
        }else{          //子进程从break跳出
                sleep(i);
                printf("I'm %dth child,pid = %d\n",i+1,getpid());
        }
        return 0;
}

实现①输出为：

-----pid= 343309
I'm 1th child,pid = 343307
I'm 2th child,pid = 343308
I'm 3th child,pid = 343309
I'm 4th child,pid = 343310
I'm 5th child,pid = 343311
----I am parent,before waitpid,pid = 343309
I'm parent,wait a child finish:343309

实现②输出为：

-----pid= 345893
----I am parent,before waitpid,pid = 345893
I'm 1th child,pid = 345891
I'm 2th child,pid = 345892
I'm 3th child,pid = 345893
I'm parent,wait a child finish:345893
I'm 4th child,pid = 345894
I'm 5th child,pid = 345895

4. waitpid回收多个子进程

一次wait/waitpid函数调用，只能回收一个子进程。上一个例子，父进程产生了5个子进程，wait会随机回收一个，捡到哪个算哪个。

练习：循环回收多个子进程

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

int main(int argc,char *argv[])
{
        int i;
        pid_t pid,wpid;

        for (i = 0;i < 5;i++){
                pid = fork();   
                if (pid == 0){//循环期间子进程不fork
                        break;
                }
        }
                if (5 == i){    //父进程从表达式2跳出
                //      while(wpid = waitpid(-1,NULL,0)){ //使用阻塞方式回收子进程
                //              printf("wait child %d\n",wpid);
                //      }
                        while((wpid = waitpid(-1,NULL,WNOHANG)) != -1){    //使用非阻塞方式回收子进程
                                if (wpid > 0){
                                printf("wait child %d\n",wpid);
                                }
                                else if(wpid == 0)
                                {
                                        sleep(1);
                                        continue;
                                }
                                sleep(1);
                        }
                }else{
                sleep(i);
                printf("I'm %dth child,pid = %d\n",i+1,getpid());
        }
        return 0;
}

输出为：

I'm 1th child,pid = 335816
wait child 335816
I'm 2th child,pid = 335817
I'm 3th child,pid = 335818
wait child 335817
wait child 335818
I'm 4th child,pid = 335819
I'm 5th child,pid = 335820
wait child 335819
wait child 335820