Linux 进程概念

目录

​编辑

一、冯诺依曼体系结构

二、操作系统(Operator System)

  2.1 概念 

  2.2 设计OS的目的

  2.3定位

  2.4如何理解 "管理"

三、系统调用和库函数概念

四、进程

  4.1 描述进程-PCB

4.1.1 task_struct-PCB的一种

  4.2 组织进程

  4.3 查看进程

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

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

五、进程状态

5.1进程状态查看

5.2 僵尸进程

5.3 孤儿进程

六、进程优先级

  6.1 基本概念

6.2 用top命令更改已存在进程的nice：

6.3 进程切换

6.4 其他概念

七、环境变量

  7.1 基本概念

  7.2常见环境变量

  7.3 查看环境变量        

  7.4 测试PATH

和环境变量相关的命令

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

1.getenv

2.char *env[ ]

3.extern char **environ

八、程序地址空间

九、进程地址空间

 那么为什么会存在地址空间呢？

---

一、冯诺依曼体系结构

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

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

1. 输入单元：包括键盘, 鼠标，扫描仪, 写板等
2. 中央处理器(CPU)：含有运算器和控制器等
3. 输出单元：显示器，打印机等

        CPU在读取和写入的时候，在数据层面为什么只和内存打交道？为了提高整机效率。在冯诺依曼体系中CPU的运行速度是非常快的，内存的运行速度是比较快的，而磁盘和一些外部设备的速度是比较慢的。根据木桶原理，如果CPU和磁盘直接交互，那么整机的速度也会下降，CPU运行再快也没用，所以退而求其次在他们两个中间通过内存传输数据。那我们写的代码，通过传输后，CPU能认识吗？这个不用担心CPU都会有自己的指令集，而我们编译的过程就是把代码转化为二进制可执行程序，就像翻译一样。

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

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

---

二、操作系统(Operator System)

  2.1 概念 

        任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)。操作系统是一个进行软硬件资源管理的软件。

        那么为什么要管理呢？通过合理的管理软硬件资源，为用户提供良好的执行环境。

操作系统包括：

        内核（进程管理，内存管理，文件管理，驱动管理）

        其他程序（例如函数库，shell程序等等）

  2.2 设计OS的目的

        与硬件交互，管理所有的软硬件资源为用户程序（应用程序）提供一个良好的执行环境。

  2.3定位

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

  2.4如何理解 "管理"

        在一个公司，有管理者，执行者和被管理者，操作系统相当于是执行者，用户相当于是管理者，被管理者相当于是电脑的底层硬件。用户做决策（命令），操作系统执行命令，然后通过驱动程序和硬件接触，让硬件开始工作。

管理的本质就是对数据做管理，管理的方法是先描述，在组织。

总结：

计算机管理硬件

1. 描述起来，用struct结构体

2. 组织起来，用链表或其他高效的数据结构

---

三、系统调用和库函数概念

        在开发角度，操作系统对外会表现为一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作系统提供的接口，叫做系统调用。

        系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或者开发者进行二次开发。

---

四、进程

        什么是进程？进程是一个运行起来（加载到内存）的程序， 是担当分配系统资源（CPU时间，内存）的实体。

  4.1 描述进程-PCB

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

4.1.1 task_struct-PCB的一种

        在Linux中描述进程的结构体叫做task_struct。

        task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息。

task_ struct内容分类

1. 标示符: 描述本进程的唯一标示符，用来区别其他进程。
2. 状态: 任务状态，退出代码，退出信号等。
3. 优先级: 相对于其他进程的优先级。
4. 程序计数器: 程序中即将被执行的下一条指令的地址。
5. 内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
6. 上下文数据: 进程执行时处理器的寄存器中的数据[休学例子，要加图CPU，寄存器]。
7. I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
8. 记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
9. 其他信息

  4.2 组织进程

        可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。所谓的对进程进行管理，变成了对进程对应的PCB进行相关的管理。

总结：进程就是内核数据结构 + 进程对应的磁盘代码。

  4.3 查看进程

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

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

        这里可以通过函数调用获取子进程和父进程的ID  （包含头文件 <unistd.h>）

        进程id（PID） -> getpid()

        父进程id（PPID） -> getppid()

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
 printf("pid: %d\n", getpid());
 printf("ppid: %d\n", getppid());
 return 0;
}

也可以通过  ps axj | grep myproc  指令直接查看（查看进程状态）

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

        可以用man手册查看fork函数，fork函数这里只粗略的讲一下，有很多东西我暂时解释不清楚。

        fork函数：作用是创建子进程，函数执行前只有一个父进程，函数执行后父进程+子进程。

        返回值这里大概的意思是：如果成功了返回子进程的ID给父进程，返回0给子进程，如果失败了，返回-1给父进程，不创建子进程并且抛异常。

 代码如下：

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
 int ret = fork();
 if(ret < 0){
 perror("fork");
 return 1;
 }
 else if(ret == 0){ //child
 printf("I am child : %d!, ret: %d\n", getpid(), ret);
 }else{ //father
 printf("I am father : %d!, ret: %d\n", getpid(), ret);
 }
 sleep(1);
 return 0;
}

运行后会发现一个震惊掉下巴的事情就是，这里会有两个返回值，并且if else语句能同时执行。

---

五、进程状态

        为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在 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 */
};

1. R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
2. S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠 （interruptible sleep））。
3. D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。
4. T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
5. t ：表示当前进程正在被追踪，也就是在进行调试的一个状态
6. X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
7. Z僵死状态（zombie）：这个下面讲

5.1进程状态查看

上面我们讲过一个指令，可以用那个指令查看进程状态，

5.2 僵尸进程

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

 僵尸进程危害：

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

5.3 孤儿进程

        如果父进程先退出，子进程后退出，子进程进入Z之后，那该如何处理呢？

         通常父进程先退出，子进程就称之为“孤儿进程” 。孤儿进程会被1号 init 进程领养，那么就应该由 init 进程回收喽。

         父进程先退出，子进程会变成孤儿进程，由S+（前台进程）变成了S（后台进程），他的父进程也变成了1号，这时普通的指令对孤儿进程不起作用，因为它根本不鸟你，需要用 kill 指令才能终止子进程。

---

六、进程优先级

  6.1 基本概念

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

        这里有几个问题需要大家思考一下：1.什么叫做优先级？2.为什么存在优先级？3.Linux中优先级的特点是什么？

        对于进程来讲，优先级一般就是谁先做谁后做，那么为什么会存在优先级呢?当然是因为可利用的资源太少了，进程一般都有很多，几十个上百个，可CPU只有一个或者几个，那么这时谁先用谁后用就体现出优先级的作用了。优先级的特点就是快，他能合理的调配资源。

        可以通过 ps -la 指令查看系统进程

UID : 代表执行者的身份

PID : 代表这个进程的代号

PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号

PRI ：代表这个进程可被执行的优先级，其值越小越早被执行

NI ：代表这个进程的nice值

        PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高。

        那NI呢?就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值，PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice    这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行。所以，调整进程优先级，在Linux下，就是调整进程nice值 nice其取值范围是-20至19，一共40个级别。需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进 程的优先级变化。 可以理解nice值是进程优先级的修正修正数据。

         最终优先级 = 原始优先级 + nice

6.2 用top命令更改已存在进程的nice：

进入top后按“r”–>输入进程PID–>输入nice值

6.3 进程切换

1.如何理解CPU？

CPU其实是一个硬件，CPU是由很多的计算单元，逻辑计算单元，寄存器，包括各种缓存构成，它是被集成在一个芯片当中，虽然很小但五脏俱全。CPU有一个很重要的功能就是存储功能，那么CPU里面会存在大量的寄存器。寄存器宏观上是分两套的，第一套是可见的，也就是用户级寄存器；还有一套是不可见的，是让操作系统去使用的寄存器。

2.计算机的工作方式是取指令，分析指令，执行指令（一个周期）；CPU是很笨的，它只会被动的帮我们执行指令，不会主动的去帮我们做一些事情。那么指令是谁提供呢？指令是由操作系统或者程序员提供的，也就是说我们平时在编程的时候，写的代码会由编译器翻译成机器指令，然后通过操作系统再让CPU去执行的。操作系统在让CPU执行指令周期的时候是以进程为载体的，通过调度的方式执行一个一个的进程。

3. CPU运行时，不是按照进程的运行时间运行的，而是CPU内部有一个时间片的设定，它会根据每个进程设置时间片，让每个进程占用CPU资源的时间都能均等，避免出现一个进程死循环后，其他进程卡顿或使用不了的情况。CPU会让进程运行一个时间片后切换下一个进程，前一个进程如果没有运行完，那么它会到运行队列里继续等待，这样用户就可以感受到，多个程序同时运行，这其实就是进程切换。

4.如果一个进程在CPU上没有运行完就被拿下来了，那么我们期望的是进程在下一次继续运行的时候能继续上一次的进度继续运行，所以我们怎么办呢？寄存器虽然只有一套硬件，但是寄存器上面的数据是属于当前进程的，因为我们进程在运行时会产生很多的临时数据，这份数据是属于当前进程的，它会和一些其他的数据临时存储在寄存器中，统称这些数据为上下文。那么我们把进程从CPU上拿下来的时候，进程的上下文也要被拿下来临时存储到其他地方，然后让别的进程去使用CPU产生上下文，等到你这个进程再次运行时再把你的上下文拿过来再继续用，这样就能在你没运行完的地方接着运行了。那么这个拿上拿下的过程也叫进程切换。

6.4 其他概念

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

---

七、环境变量

  7.1 基本概念

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

  7.2常见环境变量

PATH : 指定命令的搜索路径

HOME : 指定用户的主工作目录(即用户登陆到Linux系统中时,默认的目录)

SHELL : 当前Shell,它的值通常是/bin/bash。

  7.3 查看环境变量        

        echo $NAME //NAME:你的环境变量名称

  7.4 测试PATH

        正常我们执行自己写的可执行程序的时候要用./ 才能运行起来，那么为什么像pwd，ls等等这些指令其实也是写出来的可执行程序，却不用加./ 就能运行？

#include <stdio.h>
int main()
{
     printf("hello world!\n");
     return 0;
}

可以用 export PATH=$PATH:你的程序所在路径，把你的可执行程序所在的路径添加到环境变量中就可以像指令一样运行了。

和环境变量相关的命令

1. echo: 显示某个环境变量值

2. export: 设置一个新的环境变量

3. env: 显示所有环境变量

4. unset: 清除环境变量

5. set: 显示本地定义的shell变量和环境变量

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

正在进程的上下文中获取环境变量有三种方式：

1.getenv

#include <stdio.h>
#include <stdlib.h>

#define USER "USER"

int main()
{
    char* who = getenv(USER);
    printf("user: %s\n",who);
    return 0;
}

        getenv是以一个系统调用接口，通过指令的方式去获取环境变量，参数是环境变量的名称，返回值就是环境变量的内容。下图可以看到通过 getenv 调用环境变量得到当前的用户是谁。

2.char *env[ ]

main函数的参数其实就是命令行选项，argc表示命令行的参数有几个，argv[ ]里存储的就是命令+选项，如下面的操作演示图，其实我们执行的命令也就是通过这样的C/C++代码写出来的。

 

 这里加了env[ ] 就可以获取到系统给我传进来的环境变量。

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

 这里通过export 添加一个环境变量，再运行刚刚的程序，可以看到我们写的环境变量被添加进去了。

 也可以通过这样的方式查看我们写的环境变量

 

---

3.extern char **environ

也可以通过第三方变量environ获取环境变量

libc中定义的全局变量environ指向环境变量表,environ没有包含在任何头文件中,所以在使用时 要用extern声明。

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

 

---

八、程序地址空间

这个图我们知道它是地址空间但是它内存吗？如果不是，那是什么？先继续往下看

通过下面的代码我们发现，父子进程，输出地址是一致的，但是变量内容不一样！能得出如下结论：

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

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 0;
int main()
{
 pid_t id = fork();
 if(id < 0){
 perror("fork");
 return 0;
 }
 else if(id == 0){ //child,子进程肯定先跑完，也就是子进程先修改，完成之后，父进程再读取
 g_val=100;
 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }else{ //parent
 sleep(3);
 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val);
 }
 sleep(1);
 return 0;
}

---

九、进程地址空间

之前说‘程序的地址空间’是不准确的，准确的应该说成 进程地址空间  。

 那么为什么会存在地址空间呢？

1.如果让进程直接访问物理内存，万一进程越界非法操作呢？这样做是非常不安全的。

2. 地址空间的存在，可以更方便的进行进程和进程的数据代码的解耦，保证了进程独立性这样的特征。如果一个进程对被共享的数据做修改，则会影响其他进程，那么进程独立性这个特征的存在便没有意义。这里有个词叫 写时拷贝 ，写时拷贝是操作系统自动做的，对不同进程的数据进行分离。任意一个进程尝试修改被共享的数据，操作系统会先进行数据拷贝，然后更改页表映射的物理内存，最后再让进程进行修改。

3. 操作系统让进程以统一的视角来看待对应的代码和数据等各个区域，方便编译器也以统一的视角来进行编译代码。他们两个规则是一样的，编译完操作系统即可使用。