进程控制（Linux）

Posted 2022-12-02 雨轩（爵丶迹）

tags:

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

进程控制

进程创建
进程终止
- 进程退出情况
进程等待
进程替换
我们可以综合前面的知识，做一个简易的shell
- 总结

进程创建

进程创建有两种方式：
1、命令行启动（程序、指令等）
2、通过程序自身，fork创建子进程

fork函数

它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程

#include <unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回-1

所有 fork 出来的子进程，都是以父进程为模板的。很多代码、数据都是继承父进程。

进程调用fork，当控制转移到内核中的fork代码后，内核做：
1、分配新的内存块和内核数据结构给子进程
2、将父进程部分数据结构内容拷贝至子进程
3、添加子进程到系统进程列表当中
4、fork返回，开始调度器调度

所以创建子进程，本质是OS多了一个进程，多了一套与进程相关的数据结构，以父进程为模板。
在不写入的情况下，用户的代码和数据是父子共享的。

关于 fork ，这里有两个问题？
1、为什么 fork 会有两个返回值？fork 返回值会返回两次？
2、一个变量里，怎么会有两个不同的值，从而让父子进程执行不同的业务逻辑？

因为fork函数的整个过程是由父进程做的，此时发生了写时拷贝，父子页表数据映射到了不同的内存区域，使父子进程数据各自私有一份，此时返回值写入变量id，就会有两个不同的返回值，一个是子进程创建成功返回 0 ，一个是父进程返回子进程的 id。

fork之后，父子两个执行流就分别执行，谁先执行，由调度器决定。

fork函数返回值

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

写时拷贝

那么为什么要有写时拷贝？

保证父子进程的 “ 独立性 ”

写时拷贝的特点

1、强调是数据的写时拷贝，那么只拷贝需要写入的数据，不拷贝只读的数据，不去浪费系统内存和系统资源
2、fork时，会创建数据结构，为了提高fork的效率，不需要在去拷贝只读的数据
3、fork本身要向系统要更多的资源，当然越少，fork更容易成功

fork常规用法

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

fork调用失败的原因

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

进程终止

进程退出情况

1、代码运行完毕，结果正确。退出码 0
2、代码运行完毕，结果不正确。逻辑问题，退出码 !0
3、代码异常终止，程序崩溃了。（野指针、/0、越界…）

那什么是退出码？

退出码，可以人为的定义，也可以使用系统的错误码 list 计算机错误码 list 将int（整形）转换成string（错误码描述）

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

   int i = 0;
   for(i = 0; i < 150; ++i)
   
     printf("%d：%s\\n", i , strerror(i));//系统的错误码list
   
   return 0;

进程退出的三种情况都应该是父进程应该关心的，需要知道子进程退出的结果，需要关心它的退出码。
实际子进程退出，父进程可以关心，也可以不关心子进程的运行结果。我们这里谈论的是父进程关心子进程的运行结果。

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

从main返回
调用exit
_exit

异常退出：

ctrl + c，信号终止

1、从main返回

main函数的return 0 表示终止进程

非main函数的return不是终止进程，而是结束函数

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

  return 1;//表示函数结束，不是终止进程

int main()

  show();

2、调用exit

#include <unistd.h>
void exit(int status);
任何函数使用exit，都表示终止进程

3、_exit

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值

第2、3种情况总结：

exit：在退出的时候，会进行后续资源处理，并且会刷新缓冲区
_exit：在退出的时候，不会进行后续资源处理，直接终止进程

exit做的其他工作：

执行用户通过 atexit或on_exit定义的清理函数。
关闭所有打开的流，所有的缓存数据均被写入
调用_exit

return退出

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

以上的铺垫都是为了，站在OS的角度，理解进程终止！！！
OS的角度理解：核心思想，归还资源
1、“释放” 曾经管理进程所维护的所有的数据结构对象

释放的意思：不是真的把数据结构对象销毁，而是设置为不用状态，然后保存起来，如果不用的对象多了，就有一个“数据结构的池”。

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

不是代码和数据清空，而是把内存设置为无效

3、取消曾经该进程的连接关系

进程等待

进程等待的必要性

进程等待的必要性也就是为什么要等待？等待谁？

当fork之后会创建子进程，如果子进程挂掉或者退出，父进程不管的话，就会变成僵尸进程，一直存在系统中，从而造成内存泄漏。变成僵尸进程，就是杀不死的状态，kill -9也无能为力，因为无法去杀掉一个已经死了的进程。所以父进程要知道子进程是正常退出，还是运行完成，结果的对与不对。
所以为什么要等待，等待子进程？

1、回收僵尸进程，解决内存泄漏
2、需要获取子进程的运行结束状态 - 这点不是必须的
3、父进程要尽量晚于子进程退出，可以规范化进行子进程的资源回收、处理业务

进程等待的方法

获取子进程status

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
如果传递NULL，表示不关心子进程的退出状态信息。
否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）

ExitCode = (status >> 8) & 0xFF;//退出状态（退出码）高八位
ExitSignal = (status & 0X7F;//退出信号 低7位

系统当中也提供了两个宏来获取退出状态和退出信号

WEXITSTATUS(status)：用于获取进程的退出状态（退出码）
WIFEXITED(status)：用于查看进程是否是正常退出，本质是检查是否收到信号。

1、wait

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
成功返回被等待进程pid，失败返回-1。
参数：
输出型参数，获取子进程退出状态,不关心则可以设置成为NULL

  	1 #include <sys/wait.h>
    2 #include <stdio.h>
    3 #include <stdlib.h>
    4 #include <string.h>
    5 #include <errno.h>
    6 int main( void )
    7   
    8   pid_t pid = fork();
E>  9   if ( pid == -1 )
   10     perror("fork"),exit(1);
   11   if ( pid == 0 )
   12     int count = 5;
   13     while(count--)
   14     
E> 15       printf("child is running, ppid: %d pid: %d\\n",getppid(), getpid());
E> 16       sleep(1);
   17     
   18     exit(10);//终止子进程
   19    else 
   20     printf("father is waiting!!!\\n");
   21     int st;
   22     int ret = wait(&st);//先不关心退出的状态
   23     if ( ret > 0 && (st & 0x7F) == 0) // 正常退出
   24       printf("child exit code：%d\\n",(st>>8)&0xFF);
   25     
   26     else if( ret > 0 )  // 异常退出
   27       printf("sig node：%d\\n",st&0x7F);                                                                                                                                                          
   28   
   29 
   30

父进程一直在等待（等待任意一个子进程），当子进程退出后，wait就可以返回，此时父进程就可以拿到子进程的退出码

这里父进程等待成功，成功拿到子进程的退出码

下面来看库函数中的方法拿到退出码和退出信号

2、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。

1、如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退出信息。
2、如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
3、如果不存在该子进程，则立即出错返回

一、当options为0的时候，进程等待为阻塞等待

阻塞等待也就是上面刚刚的例子，父进程等待子进程执行完毕退出后，才会执行父进程。

子进程退出后，但PCB即相关的内核数据结构没有删除，退出码保存在数据结构中，wait拿取到当前子进程的退出码，所以父进程知道子进程已退出。

    1 #include <sys/wait.h>
    2 #include <stdio.h>
    3 #include <stdlib.h>
    4 #include <string.h>
    5 #include <errno.h>
    6 int main( void )
    7   
    8   pid_t pid;
E>  9   if ( (pid=fork()) == -1 )
   10     perror("fork"),exit(1);
   11   if ( pid == 0 )
   12     int count = 5;
   13     while(count--)
   14     
E> 15       printf("child is running, ppid: %d pid: %d\\n",getppid(), getpid());
E> 16       sleep(1);
   17     
   18     exit(10);//终止子进程
   19    else 
   20     printf("father is waiting!!!\\n");
   21     int st;
   22     pid_t ret = waitpid(pid, &st, 0);
   23     if (ret >= 0)                                                                         
   24       printf("wait child success...\\n");
   25       if (WIFEXITED(st))               
   26         printf("exit code: %d\\n", WEXITSTATUS(st));  
   27                                                   
   28       else                                        
   29       printf("killed by siganl %d\\n", WIFEXITED(st));
   30                                                     
   31                                                     
E> 32     sleep(5);//5 seconds after exit
   33                                   
   34

没有杀死子进程的情况下可以获取到退出码，我们在来看看杀死子进程，父进程是否还能获取子进程的退出码

上面两点说明了什么？
1、使用waitpid可以检测子进程的一个状态，子进程尽管被杀死也可以被父进程检测出来，从而让OS进行回收，也就不会导致子进程变成杀不死的僵尸进程了，也不会浪费系统资源。
2、被信号杀死而退出的子进程，其退出码将没有任何意义。

二、多进程创建以及等待

同时创建多个子进程，然后让父进程依次等待子进程退出

监控脚本

[dy@VM-12-10-centos process_control]$ while :; do ps axj | head -1 && ps axj | grep tuichuma | grep -v grep;echo "######################";sleep 1;done

#include <stdio.h>
  2 #include <stdlib.h>                                                                          
  3 #include <unistd.h>
  4 #include <sys/types.h>
  5 #include <sys/wait.h>
  6 int main()
  7 
  8   pid_t pids[10];
  9   int i = 0;
 10   for (i = 0; i < 5; i++)
 11     pid_t id = fork();
 12     if(id < 0)
 13       perror("fork error");
 14       return 1;
 15     
 16     if (id == 0)
 17       //child
 18       int count = 5;
 19       while(count--)
 20       
 21         printf("child is running, ppid：%d, pid：%d\\n", getppid(), getpid());
 22         sleep(1);
 23       
 24         exit(i + 1); 
 25     
 26     pids[i] = id;
 27     
 28   
 29   for (i = 0; i < 5; i++)
 30     int st = 0;
 31     pid_t ret = waitpid(pids[i], &st, 0);
 32     if (ret >= 0)
 33       //wait child success
 34       printf("wiat child success..PID:%d\\n", pids[i]);
 35       sleep(1);//睡上1秒在测试是否正常退出
 36       if (WIFEXITED(st))
 37         //exit normal
 38         printf("exit code:%d\\n", WEXITSTATUS(st));
 39       
 40       else
 41         //signal killed
 42        	printf("killed by signal %d\\n", WIFEXITED(st));
 43       
 44     
 45   
 46   return 0;
 47

三、基于非阻塞的轮流检查方案

WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

当子进程未退出时，父进程都在一直等待子进程退出，在等待期间，父进程不能做任何事情，这种等待叫做阻塞等待
我们可以不断去检查子进程的状态，当子进程未退出时，父进程可以做一些自己的事情，这种等待叫做非阻塞等待

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <stdlib.h>
  4 #include <sys/wait.h>
  5 int main()
  6 
  7   pid_t pid = fork();                                                                        
  8   if(pid < 0)
  9     printf("%s fork error\\n",__FUNCTION__);
 10     return 1;
 11   else if( pid == 0 ) //child
 12     printf("child is run, pid is : %d\\n",getpid());
 13     sleep(5);
 14     exit(1);
 15    else
 16     int status = 0;
 17     pid_t ret = 0;
 18     do
 19     
 20        ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
 21        if( ret == 0 )
 22           printf("child is running\\n");
 23        
 24        sleep(1);
 25     while(ret == 0);
 26     if( WIFEXITED(status) && ret == pid )
 27        printf("wait child 5s success, child return code is :%d.\\n",WEXITSTATUS(status));
 28     else
 29        printf("wait child failed, return.\\n");
 30        return 1;
 31     
 32   
 33   return 0;
 34

父进程每隔一段时间就会去检测子进程的情况，其他时间做自己的事，直到子进程退出，此时等待成功。

进程替换

替换原理

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

子进程进行进程程序替换后，会影响父进程的代码和数据吗？

子进程刚被创建时，父子进程共享代码和数据，当子进程要对代码和数据进行写入时，此时发生写时拷贝，进行程序替换后，并不会影响服进行的代码和数据。

那怎么进行程序替换，此时就要用到系统的exec等一系列函数。

替换函数

其实有六种以exec开头的函数,统称exec函数:

#include <unistd.h>`
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[]);

    1 #include <unistd.h>
    2 #include<stdio.h>
    3 #include<stdlib.h>
    4 int main()
    5 
W>  以上是关于进程控制（Linux）的主要内容，如果未能解决你的问题，请参考以下文章 
 Linux进程控制
 ＜Linux＞进程控制
 Linux --进程控制
 Linux进程控制
 Linux进程控制
 进程控制（Linux）