【在Linux世界中追寻伟大的One Piece】Linux进程概念

目次
1 -> 冯诺依曼体系结构
2 -> 操作体系(operator System)
2.1 -> 概念
2.2 -> 体系调用和库函数
3 -> 进程
3.1 -> 概念
3.2 -> 进程-PCB
3.3 -> 进程状态
3.3.1 -> Z(Zombie)-僵尸进程
3.3.2 -> 孤儿进程
3.4 -> 进程优先级
3.4.1 -> 概念
4 -> 环境变量
4.1 -> 概念
5 -> 地址空间
5.1 -> 程序地址空间 
5.2 -> 进程地址空间 
6 -> ​Linux2.6内核进程调理队列

---

1 -> 冯诺依曼体系结构

我们常见的计算机，如条记本。我们不常见的计算机，如服务器，大部分都服从冯诺依曼体系。

停止现在，我们所认识的计算机，都是一个个的硬件组件构成

• 输入单元：包括键盘、鼠标、扫描仪、写板等；
  
• 中央处理器(CPU)：含有运算器和控制器等；
  
• 输出单元：体现器、打印机等。
  

关于冯诺依曼，必须强调的几点：

• 这里存储器指的是内存；
  
• 不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出装备)；
  
• 外设(输入或输出装备)要输入或输出数据，也只能写入内存或从内存中读取；
  
• 所有装备都只能直接和内存打交道。
  

2 -> 操作体系(operator System)

2.1 -> 概念

任何计算机体系都包含一个根本的程序集合，称为操作体系(OS)。笼统的理解，操作体系包括：

• 内核(进程管理，内存管理，文件管理，驱动管理)。
  
• 其他程序(如函数库，shell程序等)。
  

计划OS的目的

• 与硬件交互，管理所有的软硬件资源。
  
• 为用户程序(应用程序)提供一个精良的实行环境。
  

定位
在整个计算机软硬件架构中，操作体系的定位是：一款纯正的“搞管理” 的软件。

总结
计算机管理硬件

• 形貌起来，用struct结构体。
  
• 组织起来，用链表或其他高效的数据结构。 
  

2.2 -> 体系调用和库函数

• 在开发角度，操作体系对外会体现为一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作体系提供的接口，叫做体系调用。
  
• 体系调用在使用上，功能比较底子，对用户的要求相对也比较高。所以，有心的开发者可以对这部分体系调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或开发者进行二次开发。
  

3 -> 进程

3.1 -> 概念

• 课本概念：程序的一个实行实例，正在实行的程序等。
  
• 内核观点：担当分配体系资源(CPU时间，内存)的实体。
  

3.2 -> 进程-PCB

进程信息被放在一个 叫做进程控制块的数据结构中，可以理解为进程属性的集合。PCB(Process Control Block)，Linux操作体系下的PCB是：task_struct。
task_struct-PCB的一种

• 在Linux中形貌进程的结构体叫做task_struct。
  
• task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里而且包含着进程的信息。
  

task_struct内容分类

• 标示符：形貌本进程的唯一标示符，用来区别其他进程。
  
• 状态：任务状态，退出代码，退出信号等。
  
• 优先级：相对于其他进程的优先级。
  
• 程序计数器：程序中即将被实行的下一条指令的地址。
  
• 内存指针：包括程序代码和进程相关数据的指针，还有和其他程序共享的内存块指针。
  
• 上下文数据：进程实行时处理器的寄存器中的数据。
  
• I/O状态信息：包括体现的I/O请求，分配给进程的I/O装备和被进程使用的文件列表。
  
• 记账信息：大概包括处理器时间总和，使用的时钟数总和，时间限定，记账号等。 
  

组织进程
可以在内核源代码里找到它。所有运行在体系里的进程都以task_struct链表的形式存在内核里。
查看进程
进程的信息可以通过 /proc 体系文件夹查看

• 如：要获取PID为1的进程信息，需要查看 /proc/1 这个文件夹。
  

• 大多数进程信息同样可以使用top和ps这些用户级工具来获取。
  

1. #define _CRT_SECURE_NO_WARNINGS 1
3. #include <stdio.h>
4. #include <sys/types.h>
5. #include <Windows.h>
6. #include <unistd.h>
8. int main()
9. {
10.         while (1)
11.         {
12.                 Sleep(1);
13.         }
15.         return 0;
16. }

复制代码

通过体系调用获取进程标示符

• 进程id(PID)；
  
• 父进程id(PPID)。 
  

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <Windows.h>
4. #include <unistd.h>
6. int main()
7. {
8.         printf("pid: %d\n", getpid());
9.         printf("ppid: %d\n", getppid());
11.         return 0;
12. }

复制代码

通过体系调用创建进程(初识fork)

• 运行man fork认识fork；
  
• fork有两个返回值；
  
• 父子进程代码共享，数据各自开发空间，私有一份(采取写时拷贝)。 
  

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
5. int main()
6. {
7.         int ret = fork();
9.         printf("hello proc : %d!, ret: %d\n", getpid(), ret);
11.         sleep(1);
13.         return 0;
14. }

复制代码

• fork之后通常要用 if 进行分流。
  

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <unistd.h>
5. int main()
6. {
7.         int ret = fork();
8.         if (ret < 0)
9.         {
10.                 perror("fork");
12.                 return 1;
13.         }
14.         else if (ret == 0)
15.         { //child
16.                 printf("I am child : %d!, ret: %d\n", getpid(), ret);
17.         }
18.         else
19.         { //father
20.                 printf("I am father : %d!, ret: %d\n", getpid(), ret);
21.         }
23.         sleep(1);
25.         return 0;
26. }

复制代码

3.3 -> 进程状态

Linux内核源代码：

• 为了弄明白正在运行的进程是什么意思，我们需要知道进程的差异状态。一个进程可以有几个状态(在Linux内核里，进程偶尔候也叫做任务)。
  

下面的状态在kernel源代码里界说：

1. /*
2. * The task state array is a strange "bitmap" of
3. * reasons to sleep. Thus "running" is zero, and
4. * you can test for combinations of others with
5. * simple bit tests.
6. */
7. static const char * const task_state_array[] = {
8. "R (running)", /* 0 */
9. "S (sleeping)", /* 1 */
10. "D (disk sleep)", /* 2 */
11. "T (stopped)", /* 4 */
12. "t (tracing stop)", /* 8 */
13. "X (dead)", /* 16 */
14. "Z (zombie)", /* 32 */
15. };

复制代码

• R运行状态(running)：并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
  
• S睡眠状态(sleeping)：意味着进程在等待变乱完成(这里的睡眠偶尔候也叫做可中断睡眠(interruptible sleep))。
  
• D磁盘休眠状态(disk sleep)：偶尔候也叫不可中断睡眠状态(uninterruptible sleep)，在这个状态的进程通常会等待IO的结束。
  
• T停止状态(stopped)：可以通过发送SIGSTOP信号给进程来停止(T)进程。这个被暂停的进程可以通过发送SIGCONT信号让进程继续运行。
  
• X殒命状态(dead)：这个状态只是一个返回状态，不会在任务列表里看到这个状态。
  

进程状态查看
   ps aux / ps axj 命令 
  

3.3.1 -> Z(Zombie)-僵尸进程

• 僵死状态(Zombies)是一个比较特殊的状态，当进程退出而且父进程(使用wait()体系调用)没有读取到子进程退出的返回代码时就会产生僵死(尸)进程。
  
• 僵死进程会以停止状态保持在进程表中，而且会一直在等待父进程读取退出状态代码。
  
• 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态。
  

来创建一个维持30秒的僵死进程例子：

1. #include <stdio.h>
2. #include <stdlib.h>
4. int main()
5. {
6.         pid_t id = fork();
7.         if (id < 0)
8.         {
9.                 perror("fork");
11.                 return 1;
12.         }
13.         else if (id > 0)
14.         { //parent
15.                 printf("parent[%d] is sleeping...\n", getpid());
17.                 sleep(30);
18.         }
19.         else
20.         {
21.                 printf("child[%d] is begin Z...\n", getpid());
23.                 sleep(5);
25.                 exit(EXIT_SUCCESS);
26.         }
28.         return 0;
29. }

复制代码

僵尸进程的危害

• 进程的退出状态必须被维持下去，由于他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！
  
• 维护退出状态本身就是要用数据维护，也属于进程根本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护？是的！
  
• 那一个父进程创建了许多子进程，就是不接纳，是不是就会造成内存资源的浪费？是的！由于数据结构对象本身就要占用内存，想想C中界说一个结构体变量（对象），是要在内存的某个位置进行开发空间！
  
• 内存走漏？是的！
  

3.3.2 -> 孤儿进程

• 父进程如果提前退出，那么子进程退却出，进入Z之后，那该如那边理呢？
  
• 父进程先退出，子进程就称之为“孤儿进程”。
  
• 孤儿进程被1号init进程领养，当然要有init进程接纳了。
  

#include <stdio.h> #include <unistd.h> #include <stdlib.h> int main() { pid_t id = fork(); if (id < 0) { perror("fork"); return 1; } else if (id == 0) {//child printf("I am child, pid : %d\n", getpid()); sleep(10); } else {//parent printf("I am parent, pid: %d\n", getpid()); sleep(3); exit(0); } return 0; }
  3.4 -> 进程优先级

3.4.1 -> 概念

• cpu资源分配的先后顺序，就是指进程的优先权(priority)。
  
• 优先权高的进程有优先实行权利。设置进程优先权对多任务环境的linux很有效，可以改善体系性能。
  
• 还可以把进程运行到指定的CPU上，如许一来，把不重要的进程安排到某个CPU，可以大大改善体系整体性能。
  

查看体系进程
在Linux或unix体系中，用ps -l命令则会类似输出以下几个内容：
   

​
  很容易留意到其中的几个重要信息：

• UID: 代表实行者的身份。
  
• PID: 代表这个进程的代号。
  
• PPID：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号。
  
• PRI：代表这个进程可被实行的优先级，其值越小越早被实行。
  
• NI：代表这个进程的nice值。
  

PRI and NI

• PRI也还是比较好理解的，即进程的优先级，或者普通点说就是程序被CPU实行的先后顺序，此值越小进程的优先级别越高。
  
• 那NI呢?就是我们所要说的nice值了，其表现进程可被实行的优先级的修正数值。
  
• PRI值越小越快被实行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice。
  
• 如许，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被实行。
  
• 所以，调解进程优先级，在Linux下，就是调解进程nice值。
  
• nice其取值范围是-20至19，一共40个级别。
  

PRI vs NI

• 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
  
• 可以理解nice值是进程优先级的修正修正数据。
  

查看进程优先级的命令
用top命令更改已存在进程的nice：

• top。
  
• 进入top后按“r”-> 输入进程PID->输入nice值。
  

其他概念

• 竞争性: 体系进程数目浩繁，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更公道竞争相关资源，便具有了优先级。
  
• 独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰。
  
• 并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行。
  
• 并发: 多个进程在一个CPU下采取进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发。
  

4 -> 环境变量

4.1 -> 概念

环境变量(environment variables)一样平常是指在操作体系中用来指定操作体系运行环境的一些参数如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在那边，但是还是可以链接成功，天生可实行程序，原因就是有相关环境变量资助编译器进行查找。环境变量通常具有某些特殊用途，还有在体系当中通常具有全局特性。
常见的环境变量

• PATH : 指定命令的搜刮路径。
  
• HOME : 指定用户的主工作目次(即用户登岸到Linux体系中时,默认的目次)。
  
• SHELL : 当前Shell,它的值通常是/bin/bash。
  

查看环境变量的方法
echo $NAME //NAME:你的环境变量名称。 
测试PATH
1. 创建hello.c文件
  

1. #include <stdio.h>
3. int main()
4. {
6.         printf("hello world!\n");
8.         return 0;
9. }

复制代码

2. 对比./hello实行和之间hello实行。
3. 为什么有些指令可以直接实行，不需要带路径，而我们的二进制程序需要带路径才能实行？
4. 将我们的程序所在路径加入环境变量PATH当中, export PATH=$PATH:hello程序所在路径。
5. 对比测试。
6. 还有什么方法可以不用带路径，直接就可以运行呢？
测试HOME 
用root和普通用户，分别实行 echo $HOME ,对比差异
. 实行 cd ~; pwd ,对应 ~ 和 HOME 的关系
和环境变量相关的命令

•  echo: 体现某个环境变量值。
  
• export: 设置一个新的环境变量。
  
• env: 体现所有环境变量。
  
• env: 体现所有环境变量。
  
• env: 体现所有环境变量。
  

环境变量的组织方式

​
每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以’\0’结尾的环境字符串。
通过代码如何获取环境变量

• 命令行第三个参数 ​
  

  

1. #include <stdio.h>
3. int main(int argc, char* argv[], char* env[])
4. {
5.         int i = 0;
6.         for (; env[i]; i++)
7.         {
8.                 printf("%s\n", env[i]);
9.         }
11.         return 0;
12. }

复制代码

• 通过第三方变量environ获取​
  

  

1. #include <stdio.h>
3. int main(int argc, char* argv[])
4. {
5.         extern char** environ;
6.         int i = 0;
7.         for (; environ[i]; i++)
8.         {
9.                 printf("%s\n", environ[i]);
10.         }
12.         return 0;
13. }

复制代码

libc中界说的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时 要用extern声明。
通过体系调用获取或设置环境变量 
  

1. #include <stdio.h>
2. #include <stdlib.h>
4. int main()
5. {
6.         printf("%s\n", getenv("PATH"));
8.         return 0;
9. }

复制代码

常用getenv和putenv函数来访问特定的环境变量。
环境变量通常是具有全局属性的

• 环境变量通常就具有全局属性，可以被子进程继承下去。 
  

  

1. #include <stdio.h>
2. #include <stdlib.h>
4. int main()
5. {
6.         char* env = getenv("MYENV");
7.         if (env)
8.         {
9.                 printf("%s\n", env);
10.         }
12.         return 0;
13. }

复制代码

直接查看，发现没有结果，说明该环境变量根本不存在

• 导出环境变量
  export MYENV="hello world"。
  
• 再次运行程序，发现结果有了！说明：环境变量是可以被子进程继承下去的！想想为什么？
  

实验

• 如果只进行 MYENV＝“helloworld” ,不调用export导出，在用我们的程序查看，会有什么结果？为什么？
  
• 普通变量 
  

5 -> 地址空间

研究背景

• kernel 2.6.32
  
• 32位平台
  

5.1 -> 程序地址空间 

​来段代码感受一下。
  

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
5. int g_val = 0;
7. int main()
8. {
9.         pid_t id = fork();
10.         if (id < 0)
11.         {
12.                 perror("fork");
14.                 return 0;
15.         }
16.         else if (id == 0)
17.         { //child
18.                 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
19.         }
20.         else
21.         { //parent
22.                 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
23.         }
25.         sleep(1);
27.         return 0;
28. }

复制代码

输出：
      parent[2995]: 0 : 0x80497d8        child[2996]: 0 : 0x80497d8    我们发现，输出出来的变量值和地址是一模一样的，很好理解呀，由于子进程按照父进程为模版，父子并没有对变量进行进行任何修改。但是将代码稍加改动:​
  

1. #include <stdio.h>
2. #include <unistd.h>
3. #include <stdlib.h>
5. int g_val = 0;
7. int main()
8. {
9.         pid_t id = fork();
10.         if (id < 0)
11.         {
12.                 perror("fork");
14.                 return 0;
15.         }
16.         else if (id == 0)
17.         { //child,子进程肯定先跑完，也就是子进程先修改，完成之后，父进程再读取
18.                 g_val = 100;
20.                 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
21.         }
22.         else
23.         { //parent
24.                 sleep(3);
26.                 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
27.         }
29.         sleep(1);
31.         return 0;
32. }

复制代码

输出：
      child[3046]: 100 : 0x80497e8        parent[3045]: 0 : 0x80497e8    我们发现，父子进程，输出地址是一致的，但是变量内容不一样！能得出如下结论:

• 变量内容不一样,所以父子进程输出的变量绝对不是同一个变量。
  
• 但地址值是一样的，说明，该地址绝对不是物理地址！
  
• 在Linux地址下，这种地址叫做 虚拟地址。
  
• 我们在用C/C++语言所看到的地址，全部都是虚拟地址！物理地址，用户一概看不到，由OS同一管理。
  

OS必须负责将 虚拟地址 转化成 物理地址 。
5.2 -> 进程地址空间 

​所以之前说‘程序的地址空间’是禁绝确的，准确的应该说成 进程地址空间 ，那该如何理解呢？看图：
分页 & 虚拟地址空间​

​说明：
上面的图就足矣说名题目，同一个变量，地址相同，实在是虚拟地址相同，内容差异实在是被映射到了差异的物理地址！
6 -> ​Linux2.6内核进程调理队列

​
   上图是Linux2.6内核中进程队列的数据结构。   
一个CPU拥有一个runqueue
 如果有多个CPU就要考虑进程个数的负载均衡题目。
优先级​

• 普通优先级：100～139(我们都是普通的优先级，想想nice值的取值范围，可与之对应!)。
  
• 实时优先级：0～99(不关心)。
  

运动队列

• 时间片还没有结束的所有进程都按照优先级放在该队列。
  
• nr_active: 统共有多少个运行状态的进程。
  
• ​queue[140]: 一个元素就是一个进程队列，相同优先级的进程按照FIFO规则进行排队调理,所以，数组下标就是优先级！
  
• 从该结构中，选择一个最合适的进程，过程是怎么的呢？
  1. 从0下表开始遍历queue[140]
  2. 找到第一个非空队列，该队列必定为优先级最高的队列
  3. 拿到选中队列的第一个进程，开始运行，调理完成！
  4. 遍历queue[140]时间复杂度是常数！但还是太低效了！
  
• bitmap[5]:一共140个优先级，一共140个进程队列，为了提高查找非空队列的效率，就可以用5*32个比特位表现队列是否为空，如许，便可以大大提高查找效率！​
  

逾期队列

• 逾期队列和运动队列结构一模一样。
  
• 逾期队列上放置的进程，都是时间片耗尽的进程。
  
• 当运动队列上的进程都被处理完毕之后，对逾期队列的进程进行时间片重新计算。
  

active指针和expired指针​

• active指针永久指向运动队列。
  
• expired指针永久指向逾期队列。
  
• 但是运动队列上的进程会越来越少，逾期队列上的进程会越来越多，由于进程时间片到期时一直都存在的。
  
• 不要紧，在合适的时候，只要能够互换active指针和expired指针的内容，就相当于有具有了一批新的运动进程。​
  

总结
在体系当中查找一个最合适调理的进程的时间复杂度是一个常数，不随着进程增多而导致时间成本增加，我们称之为进程调理O(1)算法。

---

感谢各位大佬支持！！！

互三啦！！！

​


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。