Linux进程概念
Posted DR5200
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Linux进程概念相关的知识，希望对你有一定的参考价值。
文章目录
一.冯若依曼体系结构
输入设备 : 计算机最终的目的是为了解决人的问题，而想解决人的问题的前提是人要将相应的数据输入到计算机当中，所以需要有输入设备
输出设备 : 计算机需要将计算后的结果提供给人，所以需要有输出设备
运算器 : 对输入的数据进行运算(算数运算/逻辑运算)
控制器 : CPU的指挥控制中心
存储器(内存) : 由于输入输出设备相比于CPU的计算速度较慢，根据木桶原理，整体计算机的速度偏慢， 因此引入了存储器(内存)，内存的特点是比输入输出设备快，但比CPU慢，因为内存具有预装数据的能力，CPU向输入设备要数据时，输入设备会把一些数据加载到内存，之后读数据就可以从内存中读取了，减少了和输入设备交互的次数，且CPU在处理数据时输入设备也可以加载数据到内存
1). 在数据层面上，CPU只和内存打交道，外设只和内存打交道
2). 常见输入设备 : 键盘，网卡，硬盘，话筒，摄像头
3). 常见输出设备 : 显示器，音响，网卡，硬盘
4). 数据要处理及程序运行之前，必须预装载到内存中
5). 寄存器不仅仅在CPU中有，其他外设中也是有的
6). 各种硬件单元之间链接用的是总线(IO总线(外设和内存)，系统总线(内存和CPU))
当你打开qq窗口，给你的好友发消息，整个数据流动过程是怎样的呢?(传输文件把显示器改为硬盘同理)
你的信息首先被加载到内存中，CPU读取内存中的信息进行打包等处理形成报文再写回到内存中，内存将数据写到你的显示器和网卡上，你的qq窗口就出现了你发的消息，信息经过网卡发送到网络中，你的好友电脑的网卡收到了你发的消息，写到内存中，CPU读取内存中的信息进行解包等处理再写回到内存中，内存将数据写到你的好友的显示器上，你的好友的qq窗口就出现了你发的消息
当外设中有数据时，外设会给CPU发信号告知CPU数据来临，CPU再控制数据加载到内存
二.操作系统
概念
任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)。笼统的理解，操作系统包括：
1). 内核（进程管理，内存管理，文件管理，驱动管理）
2). 其他程序（例如函数库，shell程序等等）
设计OS的目的
1). 与硬件交互，管理所有的软硬件资源
2). 为用户程序（应用程序）提供一个良好的执行环境
定位
在整个计算机软硬件架构中，操作系统的定位是：一款纯正的“搞管理”的软件
如何理解 “管理”
1). 和我们直接沟通的人算不算真正意义上的管理者 ?
2). 我们在校期间，见到校长的次数应该很少，校长既然都没见过你，校长是怎么进行管理的呢 ?
3). 管理者进行管理是不是一定要亲临现场呢 ?
在学校一般有三种角色，学生，辅导员，校长，学生就是典型的被管理者，校长就是典型的管理者(做决策)，辅导员是执行者(执行决策)，校长做出一个决策，让辅导员去执行，如校长打算挑3个人去参加比赛，将决策传达给辅导员，让辅导员把学生们的在校表现拿出来做参考，最终校长根据学生在校表现选出来3人，让辅导员告知这3个学生去参加比赛，在这个过程中，校长并没有和学生直接沟通，即被管理者和管理者是不需要直接沟通的，且校长(管理者)做出一个决策，是根据信息(数据)而做的。辅导员所做的事情一方面是采集信息，另一方面去做具体的事情，但如果信息量太大了以后，校长就需要对数据进行分类，同类的数据放在一起，描述信息的过程实际上是构建数据结构的过程，组织信息的过程实际上是对数据结构的管理
校长相当于操作系统，学生相当于软件或硬件资源，辅导员相当于驱动的角色
计算机管理硬件
1). 描述起来，用struct结构体
2. 组织起来，用链表或其他高效的数据结构
三.进程
什么是程序?
程序是指存储在磁盘上的静态文件，是已经编译好的可执行文件(代码 + 数据)
ELF文件类型
(1). REL (Relocatable file)
(2). EXEC (Executable file)
目标文件/可执行文件的内容是什么?
(1). objdump命令 是用查看目标文件或者可执行的目标文件的构成的gcc工具。
(2). 程序指令 + 程序数据构成可执行文件/目标文件
(3).
概念
硬盘中的可执行程序运行起来(Windows中双击.exe文件，Linux中./)会被加载到内存当中，可执行程序被加载到内存中，实际上是把用户的代码和数据加载到内存中，运行起来的程序就叫做进程，而在我们的系统中可以同时存在大量的进程(Linux使用 ps axj 查看当前进程)，我们在开机时第一个启动的程序就是操作系统，操作系统所做的一个工作是进程管理，操作系统进行进程管理是先描述，后组织，描述过程中的结构体是PCB(进程控制块)，PCB结构体中存在该进程的各种信息，组织是对这些结构体进行管理
1). 进程大小 > 可执行程序大小 ，因为操作系统要给可执行程序加上内核数据结构，方便管理
2). 为什么会存在PCB ？因为操作系统进行管理要先描述进程的各种信息
(1). 进程是如何启动的?
#include<iostream>
using namespace std;
int main()
cout<<"hello world"<<endl;
return 0;
1). 246459进程是由 bash 程序启动的
2). 246459进程调用 clone 系统调用函数创建出 246528 进程
3). 246459进程调用 wait4 函数阻塞
4). 246528进程调用execve函数加载ELF可执行文件 test
[“./test”] 是命令行参数，0x5631d46c66a0 /* 23 vars */ 是环境列表，在Linux中，是供所有应用程序可以使用的公共数据
5). 加载所依赖的相关库文件
6). 进程调用系统函数write输出字符串"hello world\\n"，上层应用函数是printf
7). 此时子进程246528调用系统函数exit_group(0)退出进程，0是进程退出码
8). 246459进程调用wait4回收退出的子进程
(2). 进程是如何结束的?
1). 调用exit_group()退出进程
2). 调用 exit() 或 _exit()退出进程
3). 进程收到中断信号
4). 运行到最后一行代码
(3). 进程运行时做了哪些事情?
(4). 进程结束时做了哪些事情?
(5). 进程运行时的内存数据在哪里?
echo $$ // 返回登录shell的PID
strace -f -s 65500 -T -o test.txt -p 进程id
// 在246459进程中启动 ./test
PCB
进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
Linux操作系统下的PCB是: task_struct，task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息。
task_ struct内容分类
标示符: 描述本进程的唯一标示符，用来区别其他进程。
状态: 任务状态，退出代码，退出信号等。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
printf("main start\\n");
printf("main end");
return 300; // 返回44,会 & 0xFF 作为返回结果,会刷新缓冲区
exit(0); // 会刷新缓冲区
_exit(0); // 不会刷新缓冲区
_Exit(0); // 不会刷新缓冲区
abort(); // SIGABORT 信号
优先级: 相对于其他进程的优先级(谁先谁后拿到资源)。
为什么要有优先级?
因为资源有限，CPU资源是有限的，进程可以有多个，所以进程需要优先级设置
程序计数器: 程序中即将被执行的下一条指令的地址。
CPU取指令，分析指令，执行指令，当进程被切换后再被调度时，可以通过程序计数器再开始执行
内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
时间片: 进程在CPU上运行的时间
上下文数据: 进程执行时处理器的寄存器中的数据。
I/O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
其他信息
标识符
首先认识一下getpid/getppid系统调用接口，分别获取该进程id和该进程的父进程id
// myproc.c内容
#include<stdio.h>
#include<unistd.h>
int main()
while(1)
printf("I am a process,pid : %d,ppid : %d \\n",getpid(),getppid());
sleep(1);
return 0;
1). getpid用来获取当前进程的pid，getppid用来获取当前进程的ppid
2). 我们多次运行同一可执行程序，可以发现进程id每次是不一样的，但父进程ppid每次都是一样的，我们查看父进程会发现父进程为 bash 进程(登录成功时会创建一个bash进程，kill -9 ppid 会把bash进程杀死，导致登录窗口挂掉)
3).子进程终止或崩溃不会影响 bash 进程
// myproc.c的内容
#include<stdio.h>
int main()
while(1)
printf("I am a process ,pid : %d ppid : %d\\n",getpid(),getppid());
int a = 1 / 0; // 使进程崩溃
sleep(1);
4). 我们在登录服务器时会自动创建bash进程，ps axj | grep bash 如果发现有多个bash进程，说明服务器有多人正在使用，杀掉bash进程自动退出登录
5). 在根目录下有一个 proc 的目录，我们可以使用 ls /proc 查看所有进程，也可以查看某个进程具体的信息
ls/proc/进程pid 查看某个进程的详细信息，由此可知，进程是知道自己所处的工作目录的
状态
1). main函数里的 return 0 是给谁返回的? 为什么main函数要有返回值 ?
答 : 因为main函数最终是被操作系统调用的，所以是返回给操作系统的(把返回值数据保存在系统级别的某些变量中，然后修改 task_struct 的 exit_code)，main函数的返回值实际上就是退出码
(1). 进程创建的目的是为了帮助我们完成某种任务，那么当任务完成时，调用者需要关心任务完成的怎么样(我们可以通过查看进程的退出码)
看如下代码，当该进程被执行完后，我们怎么知道运算结果是否正确呢?
#include<stdio.h>
int main()
int a = 30 + 40;
if(a == 70)
return 0;
else
return -1;
在这里给大家介绍一下 echo $?，该命令可以显示命令行中最近一次进程退出时的退出码，这就说明该进程运算结果是正确的
2). 我们需要通过某种状态信息来描述一个进程退出时的状态
一般一个进程退出时的状态分为3种 :
(1). 一个进程结束了(代码没有语法错误)，它的运算结果是正确的
(2). 一个进程结束了(代码没有语法错误)，它的运算结果是错误的(计算逻辑错误)
(3). 进程在代码执行期间崩溃了(代码有语法错误)
3). 当一个进程正在运行时，有的进程可能在运行状态，有的进程可能在休眠状态，有的进程可能在暂停状态，有的进程可能在新建或者就绪状态，这些也是状态信息(就绪，新建，运行，挂起，阻塞等待，退出)
4). 进程状态是可以数据化的(例如，0表示运行状态，1表示休眠状态)
以上的这些状态信息都被记录在PCB结构体当中
R（TASK_RUNNING）状态
只有在该状态的进程才可能在CPU上运行，如果只有一个单核CPU，可以同时存在多个R状态的进程，进程是R状态，不代表正在运行，而代表该进程可被调度，其他状态的进程如果想被调度，一定要将状态设置成R状态
多个R状态的task_struct会被连接到一起，称为调度队列(遵循FIFO原则)，操作系统想要调度进程，会从调度队列中选择进程去调度
S（TASK_INTERRUPTIBLE）状态
可中断的睡眠状态(浅度睡眠状态)，进程可以被杀死
处于这个状态的进程因为等待某某事件的发生（比如等待socket连接、等待信号量），而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时（由外部中断触发、或由其他进程触发），对应的等待队列中的一个或多个进程将被唤醒。
通过ps命令我们会看到，一般情况下，进程列表中的绝大多数进程都处于TASK_INTERRUPTIBLE状态（除非机器的负载很高）。毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。
// myproc.c 内容
#include<stdio.h>
#include<unistd.h>
int main()
while(1)
printf("process is running\\n");
sleep(100);
printf("process is sleeping\\n");
// 该进程为休眠状态
2262 2396 2396 2262 pts/0 2396 S+ 1000 0:00 ./myproc
D状态(TASK_UNINTERRUPTIBLE)
不可中断的睡眠状态(深度睡眠状态），不能被杀死
D状态存在的意义就在于，内核的某些处理流程是不能被打断的
内存中的一个进程想要把一些数据存到磁盘上，磁盘接到命令后，就去存储数据了，进程就开始等待磁盘存储数据的结果(即进程处于休眠状态)，但在这时，操作系统发现该进程在休眠状态，而这时内存已经严重不够了，于是操作系统将该进程杀掉了，可是磁盘存储数据失败了，磁盘向进程反馈存储失败的结果，可该进程已经被杀死了，无法给磁盘做出响应，于是造成磁盘陷入不可控的状态
因此我们可以将该进程设置为D状态，于是该进程不响应异步信号，kill -9就杀不死这个进程了！
T状态(TASK_STOPPED or TASK_TRACED)
暂停状态或跟踪状态
向进程发送一个SIGSTOP信号，它就会因响应该信号而进入TASK_STOPPED状态(除非该进程本身处于TASK_UNINTERRUPTIBLE状态而不响应信号)
向进程发送一个SIGCONT信号，可以让其从TASK_STOPPED状态恢复到TASK_RUNNING状态
// myproc.c 内容
#include<stdio.h>
#include<unistd.h>
int main()
while(1)
printf("I am a process,pid : %d,ppid : %d\\n",getpid(),getppid());
sleep(1);
kill -l 显示系统信号集
1~34为普通信号，35 ~ 64 为实时信号
当进程处于暂停状态时，给进程发信号进程不会响应信号，等到唤醒后才会处理信号
Z状态(TASK_DEAD - EXIT_ZOMBIE)
退出状态，进程成为僵尸进程，进程在退出的过程中，处于TASK_DEAD状态。
(1). 僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用）没有读取到子进程退出的返回代码时就会产生僵死(尸)进程
(2). 僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码.
(3). 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态
在这个退出过程中，进程占有的所有资源将被回收，除了task_struct结构（以及少数资源）以外。于是进程就只剩下task_struct这么个空壳，故称为僵尸。
之所以保留task_struct，是因为task_struct里面保存了进程的退出码、以及一些统计信息。而其父进程很可能会关心这些信息。(父进程读取完这些信息，task_struct 结构体会被释放掉)
至于为什么要存在僵尸进程?我们在开头已经做好了铺垫
进程创建的目的是为了帮助我们完成某种任务，那么当任务完成时，调用者需要关心任务完成的怎么样(我们可以通过查看进程的退出码及一些退出信息)
// 僵尸进程代码
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
printf("I am running\\n");
pid_t pid = fork();
// 子进程
if(pid == 0)
int count = 5;
while(count--)
printf("I am a child,pid : %d,ppid : %d,count : %d\\n",getpid(),getppid(),count);
sleep(1);
printf("child quit.....\\n");
exit(1);
// 父进程
else if(pid > 0)
while(1)
printf("I am a father,pid : %d,ppid : %d\\n",getpid(),getppid());
sleep(1);
return 0;
while :;do ps axj | head -1 && ps axj | grep myproc | grep -v grep;echo "#########################";sleep 1;done
僵尸进程危害
(1). 进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态
(2). 维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB就要一直维护
(3).那一个父进程创建了很多子进程，就是不回收，就会造成内存资源的浪费，因为数据结构
对象本身就要占用内存，因此就造成了内存泄露
孤儿进程
当一个进程的父进程退出了，而这个进程还在运行，这个进程就叫做孤儿进程，当该进程也退出时，该进程成为僵尸进程，但其父进程已经退出，没有进程来回收它，就会导致内存泄露的问题，操作系统肯定是不允许这样的情况发生，所以当一个进程的父进程退出后，该进程会被init进程（init进程的pid为1）领养，当该进程退出后，由 init 进程来回收它
// myproc.c 内容
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
printf("I am running\\n");
pid_t pid = fork();
if(pid == 0)
while(1)
printf("I am a child,pid : %d,ppid : %d\\n",getpid(),getppid());
sleep(1);
else if(pid > 0)
int count = 5;
while(count--)
printf("I am a father,pid : %d,ppid : %d\\n",getpid(),getppid());
sleep(1);
exit(0);
由运行结果可以看到，当父进程退出以后，子进程的 ppid 变为了 1，且由前台进程变成了后台进程
前台进程和后台进程
在Linux命令行中只能有一个前台进程，如果你的进程是前台进程，那么输入命令行是无效的，而后台进程有多个，因此不影响命令行的输入，想把前台进程变为后台进程，在后面加 & (杀掉后台进程使用kill -9 pid) （前台进程 R+，后台进程 R）
优先级
优先级是指谁先谁后拿到某种资源，和权限有所不同的是，权限是指能不能做某事，存在优先级的原因是因为资源有限，CPU资源是有限的，而进程是可以有多个的，因此进程需要进行优先级设置(让进程在各自特定的时间段内和CPU交互)。
调度 : 操作系统从多个进程当中选择一个进程放到CPU上
在Linux中，使用 ps -l (或 ps -al)查看系统进程
以上列表的信息含义如下 :
UID : 代表执行者的身份
PID : 代表这个进程的代号
PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
PRI ：代表这个进程可被执行的优先级，其值越小越早被执行
NI ：代表这个进程的nice值
PRI/NI
(1). PRI，即进程的优先级，或者通俗点说就是进程被CPU执行的先后顺序，此值越小进程的优先级别越高
(2). NI，进程的nice值，其表示进程可被执行的优先级的修正数值
(3). PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
这样，当nice值为负值的时候，那么该进程将会优先级值将变小，即其优先级会变高，则其越快被执行，所以，调整进程优先级，在Linux下，就是调整进程nice值
(4). nice其取值范围是-20至19，一共40个级别。
(5). Linux下默认 PRI 为 80，NI 为 0
用top命令更改已存在进程的nice
(1). top
(2). 进入top后按“r”–>输入进程PID–>输入nice值
(3). q 退出
注意 : 每次更改nice值，PRI 都会从默认值80开始加上nice值得到新的PRI，更改nice值的过程中如果超过了nice值的范围，会按边界值进行计算(即最大为19，最小为-20)
并行并发概念
(1). 竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级
(2). 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰
(3). 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行
(4). 并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发
程序计数器
时间片 : CPU分配给各个进程的时间，即该进程允许运行的时间
每个运行的进程，都有自己的 “时间片”
在任何一个时间段内，一个CPU上跑的只能有一个进程，当时间段(时间片)到了之后，进程会自己主动或者被操作系统被动的剥离下CPU，操作系统再去调度其他的进程放到CPU上。
在时间段内，CPU会执行进程的代码(默认情况下代码是从上向下执行的)，CPU执行代码的过程可分为3部分，取指令，分析指令，执行指令，CPU内部有一个eip的寄存器(指令计数器)，保存的是程序中即将执行的下一指令的地址，例如，CPU取完第1行的指令，分析执行完第一行指令后，eip里更新为第2行指令的地址，下次CPU取指令时就从eip寄存器中得到第二行指令的地址，分析执行完第二行指令后，eip寄存器自动更新成第三行指令的地址，以此类推
由上可知，所谓的函数跳转，分支判断，循环等，都是通过修改eip来完成的，这个eip就称为当前进程的程序计数器
上下文数据
当一个进程在运行的过程中，由于某种原因导致进程被切换了[进程被切换，可能在任何时间点(时间片到了或当前进程被抢占等等)]但进程还没有被执行完，那么该进程所产生的数据要怎么处理呢?
我们都知道，CPU在执行进程时，会将进程的数据暂存到CPU的存储单元的寄存器当中，然后再由运算单元根据控制单元传来的命令去进行相应的运算，最后将结果再写回到内存当中，我们把CPU存储单元的寄存器里面所暂存的数据就叫做上下文数据
如果该进程被切换后，数据就被下一进程覆盖掉了，那当再次轮到该进程执行时，还需要从头开始执行，这显然是效率很低的，所以我们需要将进程的上下文数据进行保存，当再次轮到该进程执行时，根据保存的上下文数据从上次执行的位置接着往下执行。
上下文数据会被保存到进程控制块当中(Linux下为 task_struct，程序计数器也属于上下文信息)
通过系统调用创建进程
fork()初识
1). fork()函数用来创建进程，fork()之前的代码被父进程执行，fork()之后的代码，父子都可以执行
// myproc.c 内容
#include<stdio.h>
#include<unistd.h>
int main()
// fork()之前的代码被父进程执行
printf("I am running\\n");
fork();
// fork()之后的代码，父子都可以执行
while(1)
printf("I am a process,pid : %d,ppid : %d\\n",getpid(),getppid());
sleep(1);
运行结果
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309 // 3310就是fork()出来的子进程
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
2). fork()之后，父子进程代码共享，数据各自开辟空间，私有一份(采用写是拷贝)
3). fork()之后，就有了两个进程，这两个进程谁先被调度?
答案是不确定的，两个进程被调度的顺序完全是由操作系统的调度算法决定的
4). fork()函数会有两个返回值，给父进程返回子进程pid，给子进程返回0，创建进程失败返回-1
// myproc.c 内容
#include<stdio.h>
#include<unistd.h>
int main()
printf("I am running\\n");
pid_t id = fork();
printf("pid : %d\\n",id);
sleep(1);
运行结果
I am running
pid : 3979
pid : 0
5). fork()函数的常见使用
Linux内核工程导论——进程