Linux进程控制 (万字）

Posted 2022-10-03 一起去看日落吗

tags:

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

🎇Linux：进程控制

博客主页：一起去看日落吗
分享博主的在Linux中学习到的知识和遇到的问题
博主的能力有限，出现错误希望大家不吝赐教
分享给大家一句我很喜欢的话： 看似不起波澜的日复一日，一定会在某一天让你看见坚持的意义，祝我们都能在鸡零狗碎里找到闪闪的快乐🌿🌞🐾。

🍣 🍥 🍙

🍣1. 进程创建

现阶段我们知道进程创建有如下两种方式：

命令行启动命令 (程序、指令等)。
通过程序自身，fork 的子进程。

🍥1.1 回忆fork

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

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

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

分配新的内存块和内核数据结构给子进程
将父进程部分数据结构内容拷贝至子进程
添加子进程到系统进程列表当中
fork返回，开始调度器调度

现在我们知道，创建一个进程，内核会为它分配新的内存块加载代码和数据，创建各种内核数据结构包括进程控制块PCB、地址空间、页表、构建映射关系；将父进程部分数据结构内容拷贝至子进程；添加子进程到系统进程列表(运行队列)当中；fork返回，开始调度器调度。

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以
开始它们自己的旅程，看如下程序。

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




运行结果：
[root@localhost linux]# ./a.out
Before: pid is 43676
After:pid is 43676, fork return 43677
After:pid is 43677, fork return 0

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

如下图所示:

所以，fork之前父进程独立执行，fork之后，父子两个执行流分别执行。注意，fork之后，谁先执行完全由调度器决定。

🍥1.2 fork函数的返回值

观察如下代码运行后共创建了多少个子进程，他们之间的关系是什么？

#include<stdio.h>
  2 #include<unistd.h>
  3 
  4 int main()
  5 
  6   const char* str = "hello byh";
  7   fork();
  8   fork();
  9   while(1)
 10   
 11     printf("ppid: %d, pid: %d, str: %s\\n",getppid(),getpid(),str);
 12     sleep(1);
 13                                                                                                         
 14   return 0;
 15 
 16

运行结果

这里共创建了 4 个子进程，其中 11095 fork 之后，创建了 11096 进程，最后 11096 和 11095 会再 fork 11097 和 11098。这里就算是 11098 进程，对于 test.c 中所有的代码都是共享的，只不过不会执行它以上的代码，其中 11098 进程是通过程序计数器 epi 指针知道自己该执行哪行代码的。

一般不会让父子进程做同样的事情

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

int main()

   const char* str = "hello byh";
   pid_t ret = fork();
   if(ret == 0)
   
     while(1)
     
       printf("%d\\n",ret);
       printf("%p\\n",&ret);
       printf("child,ppid: %d, pid: %d, str: %s\\n",getppid(),getpid(),str);
       sleep(1);
     
     return 0;
   
   else if (ret > 0)
   
     while(1)
     
 
       printf("%d\\n",ret);
       printf("%p\\n",&ret);
       printf("child,ppid: %d, pid: %d, str: %s\\n",getppid(),getpid(),str);
       sleep(1);
     
   
   else
     perror("fork");
   
   return 0;

运行代码

子进程创建之后，父子进程是共享代码的，我们认定 return 是代码，是和父子进程共享的代码，所以当我们父进程 return 时，这里的子进程也要 return，所以说这里的父子进程会 return 2 个值。

这里 pid_t ret = fork()，父进程调用 fork，在 return 时，子进程已经创建出来了，那么父进程就 return 子进程的 pid 来初始化 ret 局部变量，随后子进程就 return 0 ，此时必定是通过写时拷贝来完成数据的各自私有，虽然父子进程的 &ret 是一样的，但是物理内存一定是两块不同的空间。当我们理解了为啥同一个变量，却可以是两个不同的值后，再看 fork 为啥会有两个返回值时就有了新的理解角度。

注意不是 fork 创建子进程，并写时拷贝，而是 fork 创建子进程之后，父子谁先写入谁就写时拷贝，这里发生写时拷贝的原因是父子进程 return 的值用于初始化局部变量 ret 了。

一：父子进程会使 fork return 2 个值。
二 (较为准确)：返回时发生了写时拷贝。

写时拷贝的价值就是保证父子进程的独立性。

🍥1.3 写时拷贝

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

具体见下图:

在父/子修改数据时，会发生缺页中断：OS再开辟一段空间，把数据拷贝过来(写时拷贝)，重新建立映射关系；父子分开，更改读写权限。这时候再进行写操作。这样保证了父子进程的独立性。

为什么存在写时拷贝?

写时拷贝是为了保证父子进程的独立性。
节省内存和系统资源，提高 fork 的效率，减少 fork 失败的概率。

父子进程创建时，所有数据直接各自拷贝一份不行吗？？？

不使用写时拷贝也可以保证父子进程的独立性，为啥还要费劲使用写时拷贝?

所有的数据，父和子并不是都必须写入数据，有可能它们仅仅需要读取，而此时的各自拷贝是没有意义的，而且会浪费内存和系统资源。
fork 时，创建数据结构，如果还要将数据拷贝一份， fork 的效率会降低。
fork 本质就是向系统申请更多的内存资源，资源申请多了，fork 有可能就会失败。

🍥1.4 fork常规用法

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

🍥1.5 fork调用失败的原因

fork 是操作系统的接口，所以失败的原因一定是系统级别的原因。

系统中已经存在太多的进程了。
实际用户创建的进程超过了限制。

🍣2. 进程终止

🍥2.1 进程退出的三种场景

代码运行完毕，结果正确
代码运行完毕，结果不正确
代码异常终止

思考：为什么main函数总会return 0，意义何在？是否可以是其他值呢？

对于 main 函数的返回值，我们称之为进程退出码，它代表进程退出后，结果是否正确，通常进程退出码为 0 代表成功，!0 代表其它含义，如果你愿意你也可以 return 其它值。大部分情况下，main 函数跑完后，默认结果是正确的，所以以前返回的都是 0。

查看最近一次进程退出时的退出码 来衡量代码跑完对不对的

echo $?  查看退出码

1.代码运行完毕，结果正确    - 0:  success
2.代码运行完毕，结果不正确  - !0: failed → 为什么不正确？有多种可能，错误码对应字符串(strerror)
3.代码异常终止			- 程序崩溃 → 退出码没有意义，return都不会跑(可以通过某种方式获得原因，进程等待详谈)

演示 int 到 string 错误码之间的映射

运行结果

大部分情况下通常退出码是父进程关心的，因为父进程费了很大的劲把子进程创建出来干活，活干的怎么样，父进程得知道。野指针、/0、越界等都可能导致进程非正常结束，父进程也要关心这种情况，但此时退出码是无意义的。

🍥2.2 进程常见退出方法

正常退出

main 函数 return

可以看到只有 main 函数的 return 才是结束进程，非 main 函数的 return 是结束函数。

exit //终止进程

任何函数 exit，都表示直接终止进程。

异常退出

ctrl + c，信号终止

_exit函数

这是系统提供的接口，它的原型同库里的 exit 函数，那么系统的 _exit 和库函数的 exit 有什么区别 ?

exit 在退出时同默认的 return，会进行后续资源处理，包括刷新缓冲区。
_exit 在退出时，不会进行后续资源处理，直接终止进程。

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

执行用户通过 atexit或on_exit定义的清理函数。
关闭所有打开的流，所有的缓存数据均被写入
调用_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. 进程等待

🍥3.1 进程等待的必要性

之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

🍥3.2 进程等待的方法

🍙3.2.1 wait方法

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

pid_t wait(int* status);

返回值：
	成功则返回被等待进程的pid，失败则返回-1。
参数：
	输出型参数，获取子进程退出状态，不关心则可以设置为NULL。wait 的参数 int* status 会重点在下面的 waitpid 学习。

测试用例一：

父进程等待子进程退出后，wait 取子进程的 pid。

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

int main()

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

测试用例二：

相比测试用例一，更直观的等待，进程从无到有，从有到无。

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

int main()

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

监控脚本

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

测试用例三：

fork 5 个子进程后，父进程依次等待，并回收僵尸进程。

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

int main()

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

父进程退出，子进程会被操作系统领养。那么这个僵尸进程是在被操作系统领养后立马回收，还是积累到一定的僵尸进程再回收，这是由操作系统的策略决定的，同时也跟当前操作系统的状态有关系，如果操作系统发现内存资源已经很紧张了，就会提前回收。

🍙3.2.1 waitpid方法

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

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相等的子进程；
		因为父进程返回的是子进程的pid，所以父进程就可以等待指定的子进程，等待本质是管理的一种方式；
	status，
		输出型参数，我们传了一个整数地址进去，最终通过指针解引用把期望的数据拿出来。与之对应的是实参传递给形参是输入型参数；
		WIFEXITED(status)，查看进程是否正常退出，是则真，不是则假；
		WEXITSTATUS(status)，查看进程退出码，需要WIFEXITED(status)返回true，WIFEXITED(status)正常退出则返回true；
		WTERMSIG(status)，返回导致子进程终止的信号的编号，需要WIFSIGNALED(status)返回true，WIFSIGNALED(status)子进程被信号终止返回true；
	options，
		WNOHANG，若pid指定的子进程没有结束，则waitpid()函数返回0，本次不予以等待，需要我们再次等待；若非正常结束，则返回该子进程的ID；或者小于0，失败了。
		0，阻塞式等待，同wait————子进程没退出、回收，父进程等待；

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

🍥3.3 获取子进程status

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

阻塞和非阻塞

关注的是程序在等待调用结果（消息，返回值）时的状态.
阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

如果 waitpid 中的 options 传 WNOHANG ，那么等待方式就是非阻塞；如果传 0，那么等待方式就是阻塞。我们的代码都是单执行流，选择阻塞调用更简单。

例子

比如你的学习很差，所以打电话给楼上学习好的同学张三，说：张三，你下来，我请你吃个饭，然后你帮我复习一下。张三说：行，没问题，但是我在写代码，半个小时之后再来。一般一个班，学习好的人总是少数，所以你怕你电话一挂，有人又跟张三打电话求助，导致你不能及时复习，所以你又跟张三说：张三，你电话不要挂，你把电话放你旁边，我喜欢看你写代码的样子。然后你什么事都不做，就在那等待，直到张三下来。当然现实中很少有这种情况，但是这样的场景是存在的，一般是比较紧急的情况，比如你爸打电话让你做件事且告诉你不要挂电话。此时张三不下来，电话就不挂就类似于调用函数，这种等待方式就叫做阻塞等待。我们目前所调用的函数，全部是阻塞函数，不管是你自己写的、库里的、系统的，阻塞函数最典型的特征是调用 ➡ 执行 ➡返回 ➡ 结束，其中调用方始终在等待，什么事情都没做。

测试用例一：

父进程 fork 派生一个子进程干活，父进程通过 status 可以知道子进程把活做的怎么样。

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

int main()

    pid_t id = fork();
    if(id == 0)
    
        int count = 5;
        while(count)
        
            printf("child is running: %d, ppid: %d, pid: %d\\n", count--, getppid(), getpid());
            sleep(1);
                                                                                             
        printf("child quit...\\n");
        exit(123);
    
    //father
    int status = 0;
    pid_t ret = waitpid(-1以上是关于Linux进程控制 (万字）的主要内容，如果未能解决你的问题，请参考以下文章 
 中秋节爆肝万字，带你熟悉Linux进程的基本操作！！！
 万字详解Linux系列进程控制
 爆肝近万字总结----Linux进程控制系列文章，你确定不点进来看看？
 万字详解Linux系列进程概念
 万字详解Linux系列多线程
 万字详解Linux系列多线程（上）