【Linux--进程概念】

冯诺依曼体系结构

---

我们常见的计算机，如笔记本。我们不常见的计算机，如服务器，大部分都遵循冯诺依曼体系结构

截至目前，我们所认识的计算机，都是由一个个的硬件组成

• 输入单元：包括键盘、鼠标、扫描仪、磁盘、话筒、网卡
• 输出单元：显示器、磁盘、网卡、声卡、音响
• 中央处理器（CPU）：含有运算器和控制器等
• 
  关于冯诺依曼体系，必须强调几点
• 这里的存储器指的是内存
• 不考虑缓存情况这里的CPU能且只能对内存进行读写，不能访问外设（输入或输出设备）
• 外设（输入输出设备）要输入和输出数据，也只能写入内存或者从内存中读取
• 所有设备都只能直接和内存打交道。因为内存的存在，我们可以对数据做预加载，CPU在以后进行数据运算时，根本就不需要访问外设了，只需要直接伸手向内存要就可以了

操作系统（Operator System）

---

概念

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

• 内核（进程管理、内存管理、文件管理、驱动管理）
• 其他程序（例如函数库、shell程序等等）

设计OS的目的

• 与硬件交互，管理所有软硬件资源
• 与用户程序（应用程序）提供一个良好（安全、稳定、高效、功能丰富）的执行环境

定位

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

如何理解“管理”

总结
计算机管理硬件

• 1、描述起来,用struct结构体
• 2、组织起来，用链表或其他高效的数据结构

系统调用和库函数概念

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

进程

---

基本概念

进程 = 内核关于进程的相关数据结构+当前进程的代码和数据

描述进程—PCB

• PCB（process control block），Linux操作系统下的PCB是：task_struct
• 进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合

在Linux中描述进程的结构体叫做task_struct。task_struct是PCB的一种数据结构，他会被装载到RAM（内存）并且包含着进程的信息
task_struct 内容分类

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

组织进程

可以在内核源代码里找到他，所有运行在系统里的进程都以task‘_struct链表的形式存在内核里

查看进程

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

• 如：获取PID为25911的进程信息

用ps axj配合grep来过滤查看进程信息

通过系统调用获取进程标识符

• 进程id （PID）
• 父进程id（PPID）

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
 while(1)
 {
   printf("hello process,我已经是一个进程了，我的pid是%d,我的父进程id是%d！\n",getpid(),getppid());
   sleep(1);
 }
 return 0;
}

• bash–命令行解释器，本质上它也是一个进程
• 命令行启动的所有的程序，最终都会变成进程，而该进程对应的父进程都是bash

 #include<stdio.h>
 2 #include<unistd.h>
 3 #include<sys/types.h>
 4 int main()
 5 {
 6 //  while(1)
 7 //  {
 8 //    printf("hello process,我已经是一个进程了，我的pid是%d,我的父进程id是%d！\    n",getpid(),getppid()); sleep(1);
 9 //  }      
10 //
11  printf("AAAAAAAAAAAAAAAAAAA\n");
12  fork();                                            
13  printf("BBBBBBBBBBBBBBBBBBB\n");       
14  sleep(1);
15  return 0;                                                                     
16 }             

通过系统调用创建进程-fork初识

fork之后执行流会变成2个执行流
fork之后，谁先运行由调度器决定
fork之后，fork之后的代码共享，通常我们通过if和else if来进行执行流分流

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
 printf("AAAAAAAAAAAAAAAAAAA\n");
 pid_t ret = fork();
 printf("BBBBBBBBBBBBBBBBBBB pid:%d ,ppid:%d,ret:%p ,&ret:%p \n",getpid(),getppid($
 sleep(1);
 return 0;
}

给父进程返回子进程pid，给子进程返回0

进程 = 内核数据结构+进程的代码和数据 （代码：代码是只读的，数据：当有一个执行流尝试修改数据的时候，OS会自动给我们当前的进程触发：写时拷贝）
进程在运行的时候，是具有独立性的！
父子进程运行的时候也是一样的，他们代码共享，数据各自开辟空间

进程状态

看看Linux内核源代码怎么说

为了弄明白正在运行的进程是社么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux进程里，进程有时候也叫做任务）
下面的状态在kernel源代码里定义

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

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

阻塞：进程因为某种条件就绪，而导致的以中国不推进的状态–进程卡住了–阻塞一定是在等待某种资源–为什么阻塞？进程要通过等待的方式，等具体的资源被别人用完之后，再被自己使用。阻塞：进程等待某种资源就绪的过程–一定是task_struct就够体需要在某种被OS管理的资源下排队
挂起：把进程对应的相关代码和数据资源从内存中暂时转移到外设（磁盘）的这种行为称为挂起。

在test.c里面编写这一段代码

然后编译运行，我们可以看到该进程的状态为S（休眠）

修改这一段代码，然后在编译运行

可以看到现在状态变为了R（运行）

printf就是往外设打印消息，在死循环的代码中，CPU会频繁访问外设，此时外设可能未准备就绪（CPU的速度和外设比起来实在太快），此时程序就会被挂起，到等待外设的资源队列去排队

进程是R状态也不代表进程在CPU上面运行，只是代表进程在运行队列中排队

下面继续编写一段代码，然后编译运行

可以发现状态为S（休眠），所等待的资源没有就绪，所以不在运行队列排队。在外设（键盘）队列等待资源就绪

D休眠状态，不可中断休眠

kill -19 +PID 杀死程序



但是我们发现，状态为S+的进程无法用Ctrl+C来终止。带+的程序表示在前台运行，不带+的表示在后台运行。

这个时候可以用kill -9 +PID来终止在后台运行的程序。

Z(zombie)-僵尸进程

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

Linux当程序推出的时候，一般不会立即彻底退出，而是要维持一个状态叫做Z，也叫做僵尸状态–方便后续父进程（OS）读取该子进程退出的退出结果！

僵尸进程的危害

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

孤儿进程

• 父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？
• 父进程先退出，子进程就称之为“孤儿进程”。父进程的父进程（bash）会自动回收。
• 孤儿进程被操作系统（1号init进程）领养，当然要由init进程回收。如果不领养，子进程后续在退出就无人回收，会导致内存泄漏。

环境变量

基本概念

• 环境变量（environment varibles）一般是指在操作系统中用来指定擦欧总系统运行环境的一些参数
• 如：我们在编写C/C++程序的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
• 环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性

常见环境变量

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

测试PATH

添加成功之后我们就可以不使用:/myproc对myproc进行寻址，直接使用myproc来运行我们的可执行程序了

和环境变量相关的命令

1. echo ：显示某个环境变量值
2. export：设置一个新的环境变量
3. env：显示所有环境变量
4. unset：清除环境变量
5. set：显示本地定义的shell变量和环境变量

环境变量的组织方法

通过代码如何获取环境变量

1. 命令行第三个参数

#include <stdio.h>
int main(int argc, char *argv[], char *env[])
{
 int i = 0;
 for(; env[i]; i++){
 printf("%s\n", env[i]);
 }
 return 0;
}

运行结果：

2. 通过第三方变量environ获取

#include <stdio.h>
int main(int argc, char *argv[])
{
 extern char **environ;
 int i = 0;
 for(; environ[i]; i++){
 printf("%s\n", environ[i]);
 }
 return 0;
}
 

3. 通过函数获取(主流）

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
 int main()                                         
 {                                             
 	char* user  = getenv("USER");
 	if(user==NULL) perror("getenv");
  	else printf("USER:%s\n",user); 
	return 0;
 }

现在我们就来自己实现一个pwd的功能

1. 在myproc.c文件里面编写这样一段代码

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
  char* pwd  = getenv("PWD");
  if(pwd==NULL) perror("getenv");
  else printf("%s\n",pwd);
  return 0;
}

然后再通过将可执行文件mypwd添加到环境变量中去，就实现了自己编写的mypwd指令。

同时这个也就是我们在windows系统下在高级程序设置里为java、python配置环境变量一样，我们可以不用指定路径直接使用可执行程序的名称来运行程序

可以看到最后的结果与系统提供的pwd指令的结果是一样的。

环境变量本质就是一个内存级(每次重新连接服务器环境变量都是初始化的样子)的一张表，这张表是由用户在登录系统的时候，系统会重新读取配置文件，执行脚本、给特定用户形成属于自己的环境变量表。环境变量中的每一个，都有自己的用途：有的是进行路径查找的，有的是进行身份认证的，有的是进行动态库查找的，每一个环境变量都有自己的特定应用场景。

环境变量通常是具有全局属性的

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

接下来我们就来证明一下。

1. 添加环境变量，可以看到成功添加
   
2. 编写下面程序，然后编译产生可执行程序myproc。

#include<stdio.h>
#include<stdlib.h>
int main()
{
	char* env = getenv("MYENV");
	if(env){
		printf("%s\n",env);
	}
	return 0;
}

可以看到子进程成功的获取到了我们最开始添加的环境变量。

实验

如果只进行MY=“hello”,不调用export导出，再用我们的程序查看，会有什么结果呢？为什么？


总结：环境变量和本地变量都会被bash记录下来，export做的事情就是将本地变量添加到环境变量表里。

现在我们来了解一下命令行参数。
首先编写下面一段代码

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

接下来我们就可以简单的编写一个带选项的命令行指令，通过不同的参数来实现不同效果。

#include<stdio.h>
#include<string.h>             
#define NAME "mr"                             
                      
void Usage(const char* name)
{                                       
  printf("\nUsage:%s -[a][b][c]\n\n",name);
}
int main(int argc,char* argv[])
{           
  if(argc!=2) Usage(argv[0]);
          
  if(strcmp(argv[1],"-a")==0)  printf("打印当前目录    下的文件名\n");
  else if(strcmp(argv[1],"-b")==0)  printf("打印当>    前目录下的文件的详细信息\n");
  else if(strcmp(argv[1],"-c")==0)  printf("打印当>    前目录下的文件名（包含隐藏文件）\n");         
  else printf("其他功能，待开发\n");
  return 0;
}

进程优先级

基本概念

• CPU资源分配的先后顺序，就是指进程的优先权（priority）。
• 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
• 还可以把进程运行到指定的CPU上，这样一来把不重要的进程安排到某个CPU，可以大幅度提高性能

为什么要有优先级

很好理解，就像食堂为什么要排队一样。是因为在操作系统的角度看，可用资源太少，而进程又是那么多，每个进程都需要使用可用资源，自然而然的需要给进程划分优先级，谁的优先级高，谁先享受资源的使用；

PRI & NI

• PRI就是进程的优先级，或者通俗点说就是程旭被CPU执行的先后顺序，此值越小，进程的优先级就越高
• NI（nice），其表示进程可被执行的优先级的修正数据
• PRI值越小越快被执行，那么加入nice值之后，将会是的PRI变为：PRI（new）=PRI（old）+nice (PRI old都是从80开始）
• 这样，当nice值为负数的时候，那么该程序PRI值会变小，也就是优先级会变高，越快被执行
• 所以，调整进程优先级，在Linux下，即是调整进程nice值
• nice其取值范围是-20至19，一共40个级别。

PRI vs NI

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

查看进程优先级的命令

• ps -al

用top命令更改已存在进程的nice：达到修改进程优先级

步骤：

1. top
2. 进入top后按“r”–>输入进程PID–>输入nice值
3. 修改成功：按q退出，再用ps -al 查看发现修改成功

其他概念

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

程序地址空间

程序地址空间回顾

现在我们来编写这样一段代码 (mytest.c)

#include<stdio.h>
#include<unistd.h>
#include<assert.h>

int g_value = 100;//全局变量
   
int main()
{
   pid_t id = fork();
   assert(id>=0);
   if(id ==0)
   {
     //childi
     while(1)
     {
       printf("我是子进程，我的id是：%d，我的父进程是:%d,g_value:%d,&g_value:%p\n",getpid(),getppid(),g_value,&g_value);
       sleep(1);
       g_value++;//只有子进程会进行修改
     }
   }
   else
   {                                                                                                                          
     //father
     while(1)
     {
       printf("我是父进程，我的id是：%d，我的父进程是:%d,g_value:%d,&g_value:%p\n",getpid(),getppid(),g_value,&g_value);
       sleep(2);
     }
   }
   return 0;
}

我们可以发现，子进程对全局数据修改，并不影响父进程！–进程具有独立性！–进程=内核数据结构+代码和数据
同时，我们可以看到同一个变量（地址相同）但是却打印出了从不同的值，我们可以得出以下结论

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

OS负责将虚拟地址转化为物理地址

进程地址空间

所以之前说“程序的地址空间”是不准确的，准确的应该说成“进程地址空间”，那又该如何理解呢？

然后我们可以进一步讨论上面代码所涉及到的一些知识。

另外，我们可以看到if和else里面的语句都执行了，我们也可以解释这个现象了。fork返回的时候是有两个返回值的，返回的本质就是写入。谁先返回，就让OS发生写时拷贝。

进程地址空间的优点

• 1、防止地址随意访问，保护物理内存与其他进程
• 2、将进程管理和内存管理解耦合
• 3、可以让进程以统一的视角看待自己的代码和数据

现在我们来解决这样一个问题：向OS申请内存，操作系统立马给你，还是需要的时候给你呢？
很明显答案是需要的时候给

• 1、OS一般不允许任何的浪费或者不高效
• 2、申请内存，不一定马上使用
• 3、在你申请成功之后，和你使用之前就有一段小小的时间窗口–这个空间没有被正常使用，但是别人用不了–处于闲置状态