Linux之进程控制详解

Posted 2022-02-19 小赵小赵福星高照～

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux之进程控制详解相关的知识，希望对你有一定的参考价值。

进程控制

文章目录

进程控制

进程创建

进程创建的最常见的两种场景：

1、命令行启动命令(程序、指令等)

2、通过程序自身fork出来子进程

fork函数初识

在linux中fork函数时非常重要的函数，fork创建子进程是以父进程为"模板"的，很多数据代码继承父进程，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()

    cout<<"I am a process: "<<getpid()<<endl;
    pid_t id = fork();
    if(id < 0)
    
        cerr<<"fork error"<<endl;
        return 1;
    
    else if(id == 0)
    
        //child
        cout<<"I am son ："<<getpid()<<endl;
        sleep(5);
    
    else
    
        //parent
        cout<<"I am father"<<getpid()<<" My son pid："<<id<<endl;
        sleep(5);
    
    return 0;

返回值：子进程中返回0，父进程返回子进程id，出错返回-1

为什么是这样呢？任何孩子都有唯一的父亲，一个父亲可能有多个孩子，父亲需要标识孩子。所以子进程中返回0，父进程返回子进程id

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

分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程

将父进程的PCB、地址空间、页表的相关内容拷贝给子进程，但并不是所有都拷贝，比如pid

添加子进程到系统进程列表当中
fork返回，开始调度器调度

fork函数返回值

子进程返回0

父进程返回的是子进程的pid

为什么会有两个返回值呢？

fork之后会进入内核，fork函数的实现进行申请内存构建数据结构PCB，虚拟内存，页表，最后将当前新进程设置为R状态，放置进调度列表中，此时进程已经创建成功了，父子进程共享代码，fork函数的最后一个代码是返回一个值，return ret这个代码父子进程都会执行一次，所以会有两个返回值

在返回时，将函数的返回值返回给变量，发生了写时拷贝，一个变量名但是内容是不同的，本质父子页表映射数据到了不同的内存区域

写时拷贝

在不写入的情况下，父子进程共享代码和数据：

#include<stdio.h>
#include<unistd.h>
int main()

    const char *str = "hello world";
    fork();
    while(1)
    
        printf("ppid:%d,pid: %d,str: %s\\n",getppid(),getpid(),str);
        sleep(1);
    
    return 0;

可以看到代码每次执行了两次，其实是两个进程在执行

其中，默认情况下，父子进程共享代码，但是数据是各自私有一份的

代码共享：所有代码共享，因为程序计数器的原因，一般都是从fork之后开始执行，那么为什么代码要共享呢？因为代码是不可以被修改的，所以各自私有浪费空间。为什么数据要私有一份呢？因为进程之间具有独立性，如果父进程正在执行，子进程将父进程的数据改了，那就影响到了父进程。

为什么要有写时拷贝？

一个进程当中数据是有很多的，不是所有的数据都是立马使用的，并且不是所有的数据都需要进行拷贝，但是父子进程之间要独立的话，就必须将数据全部拷贝，但是这样有一个问题：把本来可以在之后拷贝的，甚至不需要拷贝的数据都拷贝了，浪费了时间和空间。fork时，创建数据结构，如果还要将数据拷贝一份，fork效率的降低。fork本身就是向系统要更多的资源，要更多的资源和要更少的资源哪一个会更容易导致fork失败呢？当然是要更多的资源

所以通常，**父子代码共享，父子再不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。**写时拷贝的识别，操作，是由OS完成

数据10M，写入的时候是1M，发生写时拷贝，是拷贝10M还是1M？答案是拷贝1M

fork常规用法

一个父进程希望复制自己，使父子进程同时执行不同的代码段。例如，父进程等待客户端请求，生成子进程来处理请求。
一个进程要执行一个不同的程序。例如子进程从fork返回后，调用exec函数。

fork调用失败的原因

系统中有太多的进程
实际用户的进程数超过了限制

总结：如何理解子进程创建？如何理解fork？

本质是系统多了一个进程，子进程要以父进程为模板(并不是将所有东西都拷贝给子进程，比如PID是不需要拷贝的)

进程终止

进程退出场景

代码跑完了，结果是对的
代码跑完了，结果是不对的
代码没跑完，程序退出了(代码异常终止)

上面的退出场景已经包括了所有的场景，情况1和情况2是用退出码进行标识的，情况3是发生了异常，会有退出原因

进程常见退出方法

main函数返回

main函数退出的时候，return的那个数字叫做进程的退出码，怎么查看进程的退出码呢？

echo $?

这个命令是查看最近一个进程的退出码

为什么main函数的return一般写成0呢？0在函数设计中，一般代表正确，非零代表出错。这里的return是给系统看，确认进程的执行结果是否正确，退出码可以人为的定义，也可以使用系统的错误码list，那么非零到底是什么意思呢？当程序运行失败的时候，我们最关心的是为什么失败？失败原因，计算机不擅长处理，擅长处理整数类型的数据，所以退出码都是整数类型的，但是我们人又擅长字符串的描述，所以就有错误码和字符串的映射：

#include<stdio.h>
#include<string.h>
int main()

    for(int i = 0;i<200;i++)
    
        printf("%d:%s\\n",i,strerror(i));
    
    return 0;

进程非正常结束：野指针，除0，越界…，退出码无意义

exit

exit和return有什么区别呢？

exit：终止整个进程，任何地方调用，都会终止

return：终止函数，如果是main函数return，代表终止进程

#include<stdlib.h>
int main()

    exit(1);

exit的参数就是进程的退出码

#include<stdlib.h>
int exe()

    exit(12);

int main()

    exe();
    cout<<"haha"<<endl;

进入exe函数，调用exit函数，此时直接就将进程终止了，并不会再去执行下面的语句了。

_exit

exit和_exit几乎一模一样，区别在于exit是库函数，_exit是系统调用，exit在退出程序时会刷新缓冲区，而_exit在退出时不会刷新缓冲区。

int main()

    cout<<"haha";//写入缓冲区
    exit();

会刷新缓冲区

int main()

    cout<<"haha";//写入缓冲区
    _exit();

不会刷新缓冲区

站在OS角度，如何理解进程终止？

进程终止的核心思想就是归还资源：

1、"释放"曾经为了管理进程所维护的所有的数据结构对象。

2、释放程序代码和数据占用的内存空间。

3、取消曾经该进程的链接关系(比如和它和它的父进程之间的链接关系)

上面提到了两个释放，所谓第一个释放不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个"数据结构的池"

第二个释放不是代码和数据清空，而是把内存设置为无效就可以了

实际上我们每次申请空间是比较耗时的，由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。而数据结构池就是，当一个进程创建时有task_struct，mm_struct等各种数据结构变量，而我们在申请这些内存时，每次都要将这块内存强转为(task_struct*)，(mm_struct*)，这样时间效率肯定不好，所以就有一个数据结构池，这里面是一些无效的pcb以及mm_struct，他们处于一个废弃队列当中，当创建进程需要内存时，就将这里的内存提取出去。

进程等待

我们首先将子进程创建出来：

int main()

    pid_t id = fork();
    if(id == 0)
    
        while(1)
        
            sleep(1);
            cout<<"child..."<<endl;
        
        exit(0);//终止
    
    else
    
        while(1)
        
            sleep(1);
            cout<<"father..."<<endl;
        
    
    cout<<"hello world"<<endl;

子进程被创建出来，谁先运行，是由调度器说了算的，那么谁先退出呢？一般而言，我们通常要让子进程先退出，为什么呢？因为父进程可以很容易对子进程进行管理(垃圾回收)，如果父进程退出，子进程就成孤儿进程了，由操作系统领养，创建子进程出来是为了处理业务的，需要让父进程拿到子进程执行的结果

一般子进程是需要被父进程等待的，父进程等待的意义就是垃圾回收以及拿到子进程执行的结果

为什么要等待？

1.回收僵尸，解决内存泄漏

2.需要获取子进程的运行结束状态

3.尽量父进程要晚于子进程退出，可以规范化进行资源回收 - 编程策略

进程等待的方法

wait方法

等待任意一个子进程，当子进程退出，wait就可以返回。

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);

返回值：

成功返回被等待进程pid，失败返回-1。

参数：

输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

int main()

     pid_t id = fork();
     if(id < 0)
     
         perror("fork");
         return 1;
     
     else if(id == 0)
     
         //child
         int count = 5;
         while(count)
         
             printf("child is runing: %d\\n,ppid:%d,pid: %d\\n",count--,getppid(),getpid());
             sleep(1);
         
         exit(0);
     
     else
     
         //father
         printf("father is waiting...\\n");
         pid_t ret = wait(NULL);
         printf("father is wait done,ret: %d\\n",ret);
     
    	return 0;

可以看到父进程等待成功了

我们来演示一下子进程变成僵尸进程后被父进程回收的过程：

我们首先让子进程五秒后退出，父进程先睡眠不进行处理，查看子进程被回收的过程：

int main()

     pid_t id = fork();
     if(id < 0)
     
         perror("fork");
         return 1;
     
     else if(id == 0)
     
         //child
         int count = 5;
         while(count)
         
             printf("child is runing: %d\\n,ppid:%d,pid: %d\\n",count--,getppid(),getpid());
             sleep(1);
         
         exit(0);
     
     else
     
         //father
         printf("father is waiting...\\n");
         sleep(8);
         pid_t ret = wait(NULL);
         sleep(3);
         printf("father is wait done,ret: %d\\n",ret);
     
    	return 0;

我们用一个脚本来监视进程的状态：

while :; do echo "####################"; ps ajx | head -1 && ps ajx | grep mytest | grep -v grep; echo "####################"; sleep 1; done

可以看到红色框圈出来的多了进程，然后之后几秒后，此时子进程退出，父进程处于睡眠状态，一直没有处理它，子进程变成了Z状态，故父进程睡眠结束后调用wait处理子进程，然后子进程彻底被杀死。

上面只是为了演示，但是实际中我们这样写就行：

int main()

    pid_t id = fork();
    if(id == 0)
    
        int count = 0;
        while(1)
        
            sleep(1);
            cout<<"child..."<<count<<endl;
            if(count>=15)
            
                break;
            
            count++;
        
        exit(0);//终止
    
    else
    
        cout<<"father before..."<<endl;
        wait(NULL);//阻塞等待，等待子进程退出
        cout<<"father after..."<<endl;

子进程退出父进程回收后继续做自己的事情就可以了。下面看另外一种方法：

waitpid方法

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

参数：

pid：
Pid=-1,等待任一个子进程。与wait等效。
Pid>0.等待其进程ID与pid相等的子进程。
status:
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。options设置成0时是阻塞式等待

返回值：

当正常返回的时候waitpid返回收集到的子进程的进程ID；
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；

WNOHANG是什么我们后面说，下面看这样一个程序：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()

    pid_t id = fork();
    if(id<0)
    
        perror("fork error!\\n");
        return 1;
    
    if(id == 0)
    
        //child
        int count = 0;
        while(count<10)
        
            printf("child [%d] is running...\\n",getpid());
            sleep(1);
            count++;
        
        exit(0);
    
    printf("father wait before!\\n");
    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0)//等待成功
    
        printf("wait success!\\n");
    
    else
    
        printf("wait failed!\\n");
    
    printf("father wait after!\\n");

当我们waitpid这样传参时其实这里的waitpid和wait的作用一样的，不一样的就是参数不同，我们来看看waitpid的第二个参数status：

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

status：是一个整形指针，其实在传参的时候，该参数是一个输出型参数

int st = 0;
waitpid(pid,&st,0);//开始等待，子进程退出，操作系统就会从进程PCB中读取退出信息，保存在status指向的变量中

返回之后，st中就保存的是进程退出的信息，int是32bit，而这个int当中就要保存这些信息：是否正常退出，退出码是多少，退出信号是多少，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特
位）：

那么为什么需要用status让父进程知道子进程的退出信息呢？是否可以通过设置全局变量，子进程如果退出将该全局变量改了，以这样的方式告知父进程子进程的退出码？这样绝对是不行的，因为写时拷贝，子进程在修改全局变量时，会发生写时拷贝，父进程和子进程指向的变量不是同一块内容。

在waitpid中拿到的status的值，是从哪里拿到的呢？答案是从子进程的task_struct中拿到的

一般进程提前终止，本质是该进程收到了OS的信号，进程先关心的是信号的内容，status指向的变量的低7位表示的是终止信号，正常终止的话，没有收到任何退出信号，此时才去关心结果对还是不对(退出码)

完整的等待过程：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()

    pid_t id = fork();
    if(id<0)
    
        perror("fork error!\\n");
        return 1;
    
    if(id == 0)
    
        //child
        int count = 0;
        while(count<10)
        
            printf("child [%d] is running...\\n",getpid());
            sleep(1);
            count++;
        
        exit(0);
    
    printf("father wait before!\\n");
    int st = 0;
    pid_t ret = waitpid(id,&st,0);
    if(ret > 0)
    
        printf("wait success!\\n");
        printf("st:%d\\n",st);
        printf("child exit signal:%d\\n",st&0x7F);//获取低7位
        printf("child exit code:%d\\n",(st>>8)&0xff);//获取高八位退出码
        if(st & 0x7F)//如果终止信号不为0 
        
        	printf("child run error!\\n");   
        
        else
        
            //终止信号为0，进程正常退出
            int code = ((st>>8)&0xff);//退出码
            if(code)//如果退出码不为0
            
                printf("child run success,but result is not right!:code ：%d",code);
            
            else
            
                printf("child run success,result is right!:code ：%d",code);
            
        
    
    else
    
        printf("wait failed!\\n");
    
    printf("father wait after!\\n");

上面的代码就是进程完整等待的过程。

但是这样拿到退出码和信号比较麻烦，实际上系统上提供了这么两个宏可以帮我们干上面的检测：

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）

这个检测的相当于是!(status & 0x7F)

WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

这个检测的相当于是(st>>8) & 0xff。

所以我们可以将上面的代码换成下面这种：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main()

    pid_t id = fork();
    if(id<0)
    
        perror("fork error!\\n");
        return 1;
    
    if(id == 0)
    
        //child
        int count = 0;
        while(count<10)
        
            printf("child [%d] is running...\\n",getpidLinux 进程控制——等待队列详解
 Linux 进程控制——等待队列详解
 Linux之进程控制详解
 linux 进程通信之 守护进程
 Linux下task_struct详解
 Linux守护进程详解(init.d和xinetd)