【Linux】了解进程的基础知识

---

1. 进程的概念

一个已经加载到内存中的程序，叫做进程（也叫任务）。有些教材也说正在运行的程序叫做进程。

1.1 进程的理解

1. 一个操作系统不仅仅运行一个进程，可以同时运行多个进程。例如操作系统本身也是个程序，它要运行起来必须先加载到内存，然后再运行某个文件，这样就同时运行两个进程。

2. 进程这么多，有的进程刚加载到内存，有的进程已经结束，有的进程还在运行。操作系统必须将进程管理起来！如何管理？先描述，再组织。

3. 任何一个进程在加载到内存，形成一个真正的进程时，OS要先创建进程的结构体对象，这个结构体对象叫做PCB（process control block/进程控制块）。PCB本质就是进程属性的集合。所以一个进程要运行时，首先会根据进程的PCB，创建对应的结构体对象初始化，再把进程的代码和数据加载到进程。所以进程 = 内核数据结构对象（描述这个进程的所有属性值，由OS创建） + 自己的代码和数据（加载到内存的可执行程序，由程序员自己维护）。
   

4. 前面我们提到OS对底层设备做管理，其实是对底层设备的结构体对象做管理，所以以后操作系统对进程做管理，只需对PCB结构体对象进行管理（因为PCB是进程属性的集合），不需要对代码和数据进行管理。操作系统对进程做管理，本质是对进程的内核数据结构（PCB对象）做管理。

5. PCB有指向代码和数据的指针，操作系统要调度进程时，会找到PCB，根据PCB指针信息找到代码和数据，再交给CPU去执行。

6. 当内存中有多个进程，怎么把所有进程管理？刚刚完成先描述，现在将PCB关联起来，完成再组织。所以，在操作系统中，对多个进程进行管理，变成对PCB单链表进行增删查改。

1.2 Linux下的进程

1. task_struct
   Linux操作系统下的PCB是: task_struct。Linux先将进程描述成tack_struct对象，再组织。Linux是怎么组织进程的？在Linux内核中，最基本的组织进程task_struct方式，是采用双向链表组织的。但是在操作系统内部，一个task_struct还有其他的链接指针，可以还会二叉树的某个节点，或者队列的某个节点，并不只有一个链接方式的指针。
2. task_struct
   （1）标示符（PID）: 描述本进程的唯一标示符，用来区别其他进程。
   （2）状态: 任务状态，退出代码，退出信号等。
   （3）优先级: 相对于其他进程的优先级。CPU数目要少于进程，这意味着进程要竞争CPU，竞争就意味有优先级。
   （4）程序计数器: 程序中即将被执行的下一条指令的地址。
   （5）内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针。
   （6）上下文数据: 进程执行时处理器的寄存器中的数据。

1.3 查看进程属性

1. 用ps或者top这两个指令来查看进程。以ps为例，ps一般带选项ajx。
   
   通常配合管道和grep使用，比如要查找myprocess的进程
   

2. 进程的信息可以通过 /proc 系统文件夹查看。

操作系统将进程信息可视化，将进程放在/proc这个文件夹中。这些蓝色数字就是目录，数字表示进程的PID，目录里面存放进程的大量属性。

ls /proc/PID 查看进程的属性

讲讲两个属性：cwd（当前工作目录），exe（可执行程序）

3. 每个进程终止后再启动，其PID大概率是变化的。

1.4 getpid和getppid

1. 如何获得进程的PID？

操作系统提供了一个系统调用接口getpid，谁调用getpid就返回谁的PID。进程调用getpid，就相当于在这个进程的task_struct中找到它的PID，然后返回给用户。getppid则返回当前进程的父进程的PID。

证明

test.c1 #include<stdio.h>2 #include<unistd.h>3 4 int main()5 {6   while(1)7   {8     printf("这个进程的PID是：%d，其父进程的PID是：%d\n",getpid(),getppid());9     sleep(1);                                                10   }11   return 0;12 }

运行这个代码后，对比打印出来的PID和PPID，与用指令查看进程属性中的PID和PPID。

2. PID只保证每次运行期间有效，下次启动进程PID可能发生变化。

3. 在命令行创建的进程，是由bash创建的，并且变成bash的子进程，每条指令都是bash的子进程。这些子进程的创建和销毁，不影响父进程。
   

---

2. 创建进程

1. 创建进程需要用到fork函数。

fork()创建子进程，如果创建成功，给父进程返回子进程的PID，给子进程返回0。如果创建失败，给父进程返回-1。

2. 例子

 12   pid_t id = fork();                                                            13   if(id == 0)                                                                   14   {                                                                             15     printf("我是子进程，我的PID是：%d\n",getpid());                             16   }                                                                             17   else18   {19     printf("我是父进程，我的PID是：%d\n",getpid());20   }                                                                                                                              

3. 疑问

（1）为什么fork要给子进程返回0，给父进程返回子进程的PID？
一般而言，fork之后的代码共享，返回不同的返回值，是为了区分，让不同的执行流执行不同的代码块（让父子进程执行不同的事情）。给父进程返回子进程的PID，用来标识子进程的唯一性，一个父进程可以有多个子进程，返回子进程的PID可以告诉父进程我是哪个子进程。
（2）fork函数究竟在做什么？
创建子进程，因为进程= 内核数据结构 + 代码和数据，所以实际上是在内存中创建对应的task_struct对象。子进程拷贝了父进程的内核数据结构，修改了部分属性（比如PID，PPID），但不会拷贝父进程的代码和数据，而是共享父进程的代码和数据。

（3）一个函数是如何做到返回两次的？
从fork函数的实现就可以看出来

pid_t fork()
{//1.创建子进程的PCB//2.填充PCB对应的内容//3.让父子进程指向同样的代码//4.父子进程都是具有独立的task_struct，可以被CPU调度执行...return ret;
}

return这句代码是在子进程被创建后与父进程共享的代码之一，被执行了两次，所以fork()会有两次返回值。

（4）一个变量怎么会有不同的内容？

4. 独立性

任何平台，进程在运行的时候具有独立性。因为数据可能被修改，不能让父进程和子进程共享一份数据。

所以让子进程拷贝父进程的数据吗？如果子进程对拷贝的数据不修改，会导致操作系统中可用资源的减少（存在重复的数据）。所以操作系统识别到如果进程要修改数据中的某部分，再将父进程数据中的这部分数据拷贝过来，再进行修改。

5. 父进程创建子进程后，谁先运行？

谁先运行由调度器决定，是不确定的。调度器挑选一个进程到CPU工作，CPU只负责运行进程。

6. 所以现在我们创建进程有两种方法：一是./运行程序（指令级别）；二是fork()（代码层面创建）。bash创建进程其实就是调用fork函数。

---

3. 进程状态

Linux操作系统中进程有运行状态(R）、睡眠状态（S）、磁盘休眠状态（D）、停止状态（T）、死亡状态（X）等。

1. 运行状态（R）

（1）运行状态：表明进程要么是在运行中要么在运行队列里。

每个CPU都有一个运行队列，运行队列中排列着进程的task_struct。凡是处于运行队列的进程，它们所处的状态叫做运行态（R态）。

（2）一个进程只要把自己放到CPU开始运行，是不是就一直执行到完毕，再将退出运行？
肯定不是，每个进程都有一个叫时间片的时间限制，一旦进程在CPU中运行时间超过时间片，就会从CPU中拉下来，如果这个进程还要运行，需要继续在运行队列排队。所以在一段时间内，所有的进程代码和数据都会被执行，这就是并发执行。如果不是并发执行，我们就不能边听音乐边写文档，不能同时运行多个进程。

把进程从CPU中拿下来放上去的动作叫做进程切换。

（3）问题：为什么运行时是S状态？为什么将打印去掉后运行时是R状态？

//测试代码1 #include<stdio.h>2 #include<unistd.h>3 int main()4 {5     6     while(1)7     {8         printf("I am a process,my pid:%d",getpid());9         sleep(1);10     }11     return 0;12 }

代码里面有printf，printf要访问显示器设备，CPU处理速度过快导致进程在显示器等待的时间远远大于进程在CPU上运行时间。所以导致肉眼看到的进程状态是S状态。
当将代码中的打印部分去掉时，

2. 睡眠状态（S）

顾名思义，阻塞状态是指进程在等待时间完成，处于等待队列的状态。
理解
操作系统是如何管理底层设备的？先描述再组织。先将底层设备描述成一个个PCB结构体对象，对象里面包括这个对象的类型，这个对象的状态，和进程等待队列。

当我们的进程在运行时读取到输入（scanf、cin等代码），需要从键盘中读取数据，但是我们不输入，此时进程就没办法在运行队列上运行，因为当前键盘没有就绪，所以我们需要让该进程链入进程的等待队列，等待硬件资源就绪。每个设备都有一个等待队列，当设备没有就绪，进程就会链入进程的等待队列中。

拓展
当处于睡眠状态的进程过多时，它们的代码和数据在内存中处于空闲的状态，在等待过程中，操作系统内部的资源严重不足。所以为保证其他进程正常运行，需要省出内存资源。操作会把处于等待状态的进程的代码和数据交换到外设（磁盘），只留下进程的PCB在等待队列，节省内存资源。

问题
平时我们所说的阻塞状态与睡眠状态有什么区别吗？
（1）睡眠状态是进程本身拥有的状态，而阻塞状态则是用来描述进程的状态；
（2）睡眠状态是自动的，进程主动进入睡眠状态，主动进入等待队列等待，不获取CPU资源，不参与进程的调度，让其他进程获取CPU资源，而阻塞状态是被动的，必须等待某件事件的完成才能被CPU调度。
（3）一般可以认为睡眠状态是阻塞状态。

4. 磁盘休眠状态（D）

磁盘休眠状态一般也叫不可中断休眠状态、深度睡眠。当进程向磁盘写入时，由于磁盘写入速度较慢，进程只能等待磁盘写入完毕才能向上层反馈。在此期间，如果计算机内存严重不足，操作系统已经用尽浑身解数去优化内存，但还是内存不足，此时它就将目标转向等待的进程，直接kill进程，这也是为什么有时内存不足时，有些程序会闪退。杀掉进程后，因为磁盘写入数据有可能失败，如果失败磁盘要向进程报告，但此时进程已被杀掉，磁盘找不到进程就可能把数据丢掉，如果是这份数据异常重要，比如银行的转账记录，那岂不是造成很大的损失。
所以就有了进程的磁盘休眠状态。当进程在等待磁盘写入完毕之前，这个进程不能被任何人杀掉，这就是进程的D状态。当磁盘写入完毕后，进程就从D状态改为R状态。
D状态的进程不响应操作系统的任何请求，只能自己醒来。

5. 停止状态（T）

（1）可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。利用kill -l将信号名称显示，其中就有我们需要的信号。

（2）例子


（3）T状态与S状态有什么区别
处于T状态的进程可能在等待资源，也可能没在等待（这个进程被控制，单纯不能运行）；处于S状态的进程一定在等待资源。

6. 终止状态（X）

进程结束，释放进程所有资源，这就是进程的终止状态。这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

7. 僵尸状态（Z）

（1）当一个子进程退出，父进程没有获取子进程的退出信息或者没有调用wait/waitpid回收子进程的资源，这个子进程变成僵尸进程（跳出三界之外，不在五行之中，此时的僵尸进程不能用kill杀死）。
例子

//模拟场景：子进程先退出，但父进程没有回收子进程的资源
int main()
{//创建子进程pid_t id = fork();if(id<0){perror("fork");}else if(id == 0)//子进程{   int cnt = 20;while(cnt--){cout<<"i am child process,my pid is "<< getpid() <<endl;sleep(1);}}else//父进程{//父进程一直循环，等待子进程退出while(1);}
}

结果
kill -9 命令也无法杀掉僵尸进程

子进程一般退出的时候，如果父进程没有主动回收子进程资源，子进程就会一直处于Z状态

（2）那么僵尸进程的危害是什么？很明显，只要父进程不回收子进程的资源，子进程就一直处于僵尸状态，一直占用内存资源，这就会造成内存泄漏。

（3）怎么避免僵尸进程？父进程得等待子进程先退出，且调用wait/waitpid获取子进程的退出信息。

（4）问题：为什么当杀掉父进程后，父进程不会变成僵尸进程？子进程会被释放？

8. 孤儿进程

（1）讨论僵尸进程时，我们注意到其前提：子进程先退出，父进程后退出。那如果是父进程先退出，子进程后退出呢？也就算上面遇到的问题。父进程先退出，子进程后退出时，我们把子进程叫做孤儿进程。
（2）例子

int main()
{//模拟场景：父进程先退出，子进程一直循环//创建子进程pid_t id = fork();if(id<0){perror("fork");}else if(id == 0)//子进程{   //让父进程比子进程先退出int cnt = 10;while(cnt--){cout<<"i am child process,my pid is "<< getpid() <<endl;sleep(1);}}else//父进程直接退出，不回收子进程的资源{int cnt = 5;while(cnt--){sleep(1);}}return 0;
}

结果

（3）子进程为什么要被领养？
因为孤儿进程未来也要退出，也要被释放。所以只能由OS来承担这个重任。

---

4. 进程优先级

1. 概念

CPU资源分配的先后顺序，就是指进程的优先权。优先级和权限没有任何关系，优先级表示对于资源的访问的谁先谁后，权限表示能否访问资源。

2. 为什么要有进程的优先级？

因为资源是有限的，进程是大量的，这注定了大量的进程要争夺有限的资源。而OS为了保证进程之间公平竞争，确立优先级。如果进程长时间得不到CPU资源，该进程的代码长时间得不到推进，就会导致进程的饥饿问题。

3. 如何查看进程的优先级？

a. PRI表示进程优先级，它的取值范围是[0,139]。其中[0,99]之间的值是给实时进程用的，[100,139]是给普通进程用的，我们的进程一般都是普通进程，所以只需关注[100,139]之间的取值。值越小进程优先级越高，被CPU执行的顺序越靠前。
b. NI表示进程的NICE值，它可以修正进程的优先级。公式为PRI(new) = PRI(old) + nice。当nice为负值时，PRI越小，优先级越高。所以在Linux中调整优先级就是调整NI值。
c. 这是否意味着可以任意改变NI值，提供进程的优先级，从而使我的进程一直被调度？并不是。Linux不想让用户过多地参数优先级的调整，只允许让我们在一定的范围内进行优先级调整。即nice的取值范围为[-20,19]。

4. 如何修改进程的优先级？

需要用到top指令，输入top后可以看到进程的调度情况。然后输入r 进程PID NICE值。注意设置新的PRI(new)看的是PRI(old)，这个PRI(old)是历史上的第一次优先级。

5. OS是如何根据优先级开展进程的调度的？即OS是怎么把优先级高的进程先执行，优先级低的后执行？
   

综上
我们可以得出进程的两个性质：竞争性和独立性。

1. 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级。
2. 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰。

---

5. 进程切换

1. 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行。并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发。
2. 一般我们的CPU都是单核，采用的是并发的方式。我们可以同时听歌、写文章、与他人聊天都得益于进程的并发。但是为什么我们没有感受到并发带来的影响（比如卡顿）？因为CPU切换进程速度快，我们感受不到。
3. 一个进程放在CPU上，是不是得让这个进程一直跑完，才可以让它从CPU下来？并不是。如果是这样，那其他进程怎么办？OS规定，每个进程都有一个时间片，如果进程在这个时间段内跑完就销毁，如果跑不完就从CPU上剥离下来放到等待队列，继续排队，这个过程就叫做进程切换。这种基于进程切换和时间片轮转的调度算法就是CPU的调度算法。
4. 为什么从CPU上剥离下的进程会被放到等待队列？这个进程是不能放到运行队列，因为它本是运行队列中优先级最高的，放到运行队列CPU不就又调度它了吗？
5. 进程怎么切换？通过CPU中的寄存器。CPU中有很多寄存器，包括通用寄存器（eax,ebx,ecx,edx）、维护栈帧的寄存器（ebp,esp,eip）、状态寄存器（status）等。它们主要是为了提高CPU运行效率，将高频使用的数据放入寄存器中。例如，系统如何得知进程当前执行到哪行代码？通过程序计数器（PC指针/eip）记录当前进程正在执行指令的下一行指令的地址。
   CPU寄存器保存的是进程的临时数据，叫做进程的上下文。进程从CPU离开时，要将自己的上下文数据保存甚至带走，主要目的是为了未来恢复。
   所以进程在被切换时做了两个工作：保存上下文（离开）；恢复上下文（运行）。
6. CPU的临时数据保存在哪里？放到进程task_struct的结构体里面。

---

6. 环境变量

1. 概念

环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数。有点抽象，先讲几个环境变量。

2. 例子

（1）PATH
a. 问题
当我们运行自己的程序和运行系统的指令时，我们发现为什么运行自己的程序时要带 ./，而运行系统的指令时却不用带 ./ ？

b. 什么是PATH？
PATH是系统自带的指令搜索路径。当运行指令时，shell会在PATH中找路径。

c. 问题答案
指令的路径放在PATH中，而我们自己的命令放在当前目录下，没有放在PATH中。shell会在PATH中查找运行程序的路径，找不到我们程序的路径，所以只能我们自己带 ./。

d. 如果我偏不想带 ./？想让我们的程序像指令一样，该怎么做？
法一，可以将我们的程序拷贝到/usr/bin目录下；法二，直接将我们的程序的路径拷贝到PATH中。
怎么在PATH中新添路径？

（2）HOME：用户登录到Linux系统的默认目录。

（3）SHELL：当前Shell,它的值通常是/bin/bash。

（4）HISTSIZE：保存历史命令的条数。

（5）SSH_TTY：当前终端设备文件。
（6）PWD：记录当前所处的工作目录；OLDPWD：记录上一次所处的工作目录。

还想获取更多环境变量，可以用指令env查看。

3. 用getenv获取环境变量

例子

int main()
{//getenvcout<<"PATH:"<<getenv("PATH")<<endl;cout<<"WHO:"<<getenv("USER")<<endl;return 0;
}

4. 为什么我们能在我们的程序中获得环境变量？

我们运行的进程都是子进程，bash本身在启动的时候，会从操作系统的配置文件中读取环境变量信息，子进程会继承父进程交给我的所有环境变量。所以环境变量具有全局属性。
证明环境变量被子进程继承
如何证明？在bash新增一个环境变量，然后子进程继承并打印，看看有没有bash中新增的环境变量。

//子进程代码
int main(int argc,char*argv[],char*env[])
{int i = 0;for(; env[i]; i++){cout<<env[i]<<endl;}
}

那如何销毁环境变量？

那如何在代码中获得环境变量？
（1）法一：通过命令行的第三个参数

int main(int argc, char *argv[], char *env[])//这三个参数等下讲，只需知道env是字符指针数组，指向环境变量
{int i = 0;for(; env[i]; i++){cout<<env[i]<<endl;}return 0;
}

（2）法二：通过第三方变量environ获取
environ是C库定义的一个全局变量，指向环境变量表。

int main(int argc, char *argv[])
{extern char **environ;//environ没有包含在任何头文件中,所以在使用时 要用extern声明int i = 0;for(; environ[i]; i++){cout<<environ[i]<<endl;}return 0;
}

（3）法三：通过系统调用getenv()，相较于前两种方法，这种方法更适合获取单个环境变量。

5. 命令行参数

（1）main函数是可以接收参数的，这些参数就是命令行参数。

int main(int argc,char*argv[])

其中argv是指针数组，指向命令行的字符串；argc是命令行字符串的个数。argv有argc个元素。命令行参数以空格为分隔符，将输入的字符串打散成几个字符串，记下有多少个字符串放到argc，将每个字符串的地址放到argv中，再通过传参给main函数。（这表明实际上main函数并不是程序真正的入口）

（2）例子：打印命令行参数

int main(int argc,char*argv[])
{int i = 0;for(;i<argc;i++){printf("argv[%d]:%s\n",i,argv[i]);}return 0 ;
}

（3）获取命令行参数的意义是什么？
为指令、工具、软件等提供命令行选项的支持。
例子

int main(int argc,char*argv[])
{//如果命令行参数不足两个，或者超过两个，给出提醒if(argc != 2) {printf("Usage: %s -[a|b]\n", argv[0]);return 0;}if(strcmp(argv[1], "--help")==0){printf("Usage: %s -[a|b]\n", argv[0]);}else if(strcmp(argv[1], "-a") == 0){printf("功能1\n");}else if(strcmp(argv[1], "-b") == 0){printf("功能2\n");}
}

（4）第三个命令行参数

int main(int argc,char*argv[],char*env[])

env是指针数组，指针指向环境变量。

---

7. 本地变量与内建命令

1. 本地变量是在命令行直接定义，只在bash内部有效的变量。本地变量不能被子进程继承。

2. set可以查看系统中所有的本地变量和环境变量。

3. 问题：

bash定义一个本地变量MY_ENV，echo是一个指令，也是bash的子进程，它为什么能打印父进程的本地变量？不是说本地变量不能被子进程继承吗？
命令行上的命令并不是全部要创建子进程。

4. 命令可以分为两类：一类是常规命令：通过创建子进程替父进程完成；一类是内建命令：bash不创建子进程，而是由自己亲自执行，类似于bash调用了自己写的或者系统提供的函数。

---