暑假补卷1——进程概念

厉凡818

已于 2023-08-22 16:38:20 修改

阅读量74

点赞数

分类专栏： Linux系统编程文章标签： linux c语言

于 2023-08-05 16:53:01 首次发布

本文链接：https://blog.csdn.net/m0_60440185/article/details/132121660

版权

Linux系统编程专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本节重点：

认识冯诺依曼系统
操作系统概念与定位
深入理解进程概念，了解PCB
学习进程状态，学会创建进程，掌握僵尸进程和孤儿进程，及其形成原因和危害
了解进程调度，Linux进程优先级，理解进程竞争性与独立性，理解并行与并发
理解环境变量，熟悉常见环境变量及相关指令, getenv/setenv函数
理解C内存空间分配规律，了解进程内存映像和应用程序区别, 认识地址空间。
选学Linux2.6 kernel，O(1)调度算法架构

冯诺依曼体系结构

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

一些理解

输入设备：产生数据

输出设备：保存或显示数据

那为什么要有存储器？直接在前两者之间插个CPU不就行了？

一定的效率和节约成本

1.CPU读取数据(数据+代码)，都是要从内存中读取。站在数据的角度，我们认为CPU不和外设直接交互(间接或其他方式交互也有可能)。

DMA技术除外，否则将外设数据搬到内存中还是需要CPU参与

2.CPU要处理数据，需要先将外设中的数据，加载到内存。站在数据的角度，外设直接只和内存打交道。

加载数据可能是操作系统直接加载，要么就是自己的程序自己给自己加载。

CPU不和外设打交道，只和内存打交道。

从外设搬到内存的过程叫做"Input"

当数据从内存到外设，叫"Output"。

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

输入单元：包括键盘, 鼠标，扫描仪, 写板等

中央处理器(CPU)：含有运算器和控制器等

输出单元：显示器，打印机等

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

这里的存储器指的是内存

不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出设备)

外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。

一句话，所有设备都只能直接和内存打交道。

操作系统(Operator System)

概念

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

内核（进程管理，内存管理，文件管理，驱动管理)(系统接口之下)

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

设计OS的目的

与硬件交互，管理所有的软硬件资源

为用户程序（应用程序）提供一个稳定、安全、简单的执行环境。

定位

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

如何理解"管理"

管理的例子

描述被管理对象

组织被管理对象

总结

计算机管理硬件

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

系统调用和库函数概念

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

由操作系统提供的接口，叫做系统调用。

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

进程

基本概念

课本概念：程序的一个执行实例，正在执行的程序等

内核观点：担当分配系统资源（CPU时间，内存）的实体。

Linux内核是用C语言写的

文件=内容+属性

描述进程-PCB

进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。

课本上称之为PCB（process control block），Linux操作系统下的PCB是: task_struct

task_struct-PCB的一种

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

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

task_ struct内容分类

标示符: 描述本进程的唯一标示符，用来区别其他进程。

状态: 任务状态，退出代码，退出信号等。

优先级: 相对于其他进程的优先级。

程序计数器: 程序中即将被执行的下一条指令的地址。

内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针

上下文数据: 进程执行时处理器的寄存器中的数据[休学例子，要加图CPU，寄存器]。

I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。

记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。（评估某些调度算法是否合理，反向指导我们的调度策略

其他信息

前后双链表节点的指针

组织进程

可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。

查看进程

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

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

cwd：当前工作目录(进程的属性)

exe：当前进程所在路径

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

 $ ps axj | head -1 && ps axj |grep 进程id //查看id进程的信息命令

 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
 int main()
 {
  while(1){
  sleep(1);
  }
  return 0;
 }

ps查看临时数据：

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

每一次登录都有新的bash(shell程序）来服务用户，进程都是bash的子进程。

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

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

运行 man fork 认识fork

（Eork创建多进程，一条print打印两次）

Eork有两个返回值

父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）

fork 之后通常要用 io 进行分流

进程状态

进程调度，变成了task_struct的队列中选择一个进程的过程，操作系统和cpu运行某一个进程，本质从task_struct的队列中挑选一个task_struct，来执行他的代码

task_struct感性认识：

文件=内容+属性，属性和代码没有太大关系。

对进程的管理，变成了对进程PCB结构体(包含了进程的属性)链表的增删改查

进程=对应的代码和数据+进程对应的PCB结构体

linux进程状态官方解说

系统中一定是存在各种资源的(不仅仅是CPU) 网卡，磁盘，显卡，等其他设备

等待输入就是等待键盘数据（非CPU资源）就绪，就是阻塞状态

内存快不足的时候，操作系统会将长期不执行的进程代码和数据换出到磁盘

挂起状态置换进程的代码和数据放到磁盘的SWAP分区。交换消耗大量资源，会使操作系统变慢，甚至崩溃（宕机）
R运行状态（running）:

并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。

R+：当前进程是前台任务，且可以被键盘ctrl+c终止，占据对话框(bash)，执行命令没有任何效果。

R:后台进程(&),不影响命令行交互。

S睡眠状态（sleeping):

意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠

（interruptible sleep））。

D磁盘休眠状态（Disk sleep)：

有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束(自动苏醒/关机)。

当服务器压力过大的时候，OS会通过一定的手段，杀掉一些进程，来起到节省空间的作用

而D状态就是防止进程等待磁盘资源就绪的过程中被操作系统杀死(操作系统杀不死D状态进程)，意味着D进程结束只能等自动结束或者关机

T停止状态（stopped）：

可以通过发送 SIGSTOP (暂停)信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT (继续)信号让进程继续运行。

暂停状态不等待资源，单纯暂停。

应用场景：调试

调试（打断点（gdb检测发送19号信号))

X死亡状态（dead）：

标识进程可以被回收(操作系统还没来得及回收)

这个状态只是一个返回状态，你不会在任务列表里看到这个状态。

进程状态查看

Z(zombie)-僵尸进程

两个问题：

是什么：一个进程已经退出，但是还不允许被OS释放，处于一个被检测的状态——僵尸状态

为什么：维持该状态，为了让父进程和OS来进行回收

怎么办：(挖个坑后面填....)

进程已退出，但是资源没办法立即释放，需要操作系统或父进程用某种方法回收没有读取到子进程退出的返回代码(进程处于被检测状态)时就会产生僵死(尸)进程

僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用,后面讲）

僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。

所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态

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

 #include <stdio.h>
 #include <stdlib.h>
 int main()
 {
     pid_t id = fork();
     if(id < 0){
         perror("fork");     
         return 1;
 }
    else if(id > 0){ //parent
         printf("parent[%d] is sleeping...\n", getpid()); 
         sleep(30);
     }else{
         printf("child[%d] is begin Z...\n", getpid());
         sleep(5);
         exit(EXIT_SUCCESS);
     }
     return 0;
 }

僵尸进程危害

进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！

维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护？是的！

那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！

内存泄漏?是的！

如何避免？后面讲

进程状态总结

至此，值得关注的进程状态全部讲解完成，下面来认识另一种进程

（总结如下附图）

ctrl+c和ctrl+的区别

ctrl+c和ctrl+z都是中断命令,但是他们的作用却不一样.

ctrl+c是强制中断程序的执行,

而ctrl+z的是将任务中断,但是此任务并没有结束,他仍然在进程中他只是维持挂起的状态,用户可以使用fg/bg操作继续前台或后台的任务,fg命令重新启动前台被中断的任务,bg命令把被中断的任务放在后台执行.

一些注解：

```
 ps axj | grep myproc
```
是什么意思

命令ps axj是用于显示当前系统上所有进程的详细信息。|用于将前一个命令的输出作为后一个命令的输入。

而grep myproc是用于在输入的文本中查找包含"myproc"字符串的行。

因此，ps axj | grep myproc的意思是从系统的进程列表（通过ps axj命令获取）中筛选出包含"myproc"字符串的行，并将其显示出来。这个命令通常用于查看指定进程名称对应的进程信息。

```
 while :; do ps ajx | head -1 && ps axj | grep myproc |grep -v grep; sleep 1; echo "-----------------------------------------------------";done
```
是什么意思
这段代码是一个无限循环的Bash脚本。让我逐步解释它的意思：
1. while :; do 是一个无限循环的开头，表示脚本将一直执行以下操作直到手动中断。
2. ps ajx | head -1 将显示当前所有进程中的第一行，并使用详细的格式 (a：显示包含其他用户的进程，j：使用长格式输出)。这可以提供有关系统当前运行的进程的一些信息。
3. ps axj | grep myproc |grep -v grep 从系统的进程列表中筛选出包含"myproc"字符串的行，并排除包含"grep"的行。此命令用于查找指定进程名称（"myproc"）对应的进程信息。管道符“|”用于将前一个命令的输出作为后一个命令的输入。
4. sleep 1 暂停脚本运行1秒钟，以便在每次循环之间有一点延迟和间隔。
5. echo "-----------------------------------------------------" 输出减号分割线，用于在每次循环之间提供可读性。
因此，整个脚本的功能是持续地输出有关第一个进程的详细信息，以及与"myproc"相关的进程信息，并在每次输出之间加上一个分割线

孤儿进程

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

父进程先退出，子进程就称之为“孤儿进程”

孤儿进程被1号init进程领养，当然要有init进程回收喽。

孤儿进程是运行在后台的

进程优先级

基本概念

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个级别（在不打破进程调度均衡的基础上微调，所以范围有区间）。

每次设置优先级，都要从进程最开始的优先级开始设置(默认从80开始调)

优先级不是随随便便能改的，改了也不一定按照期望的实现

PRI vs NI

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

查看进程优先级的命令

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

top

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

每次设置优先级，都要从进程最开始的优先级开始设置。

nice一般是-20~19

可以再输入进程id 和nice值

其他概念

竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级

独立性:多进程运行，需要独享各种资源，多进程运行期间互不干扰

并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行

并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发

ps：时间片->抢占和出让

抢占：优先级更高进程到来会抢占正在CPU运行的低优先级的进程原本分配的时间片

出让：进程想不开了主动退出CPU资源

如果进程A正在被运行，cpu内的寄存器里面，一定保存的是进程A的临时数据(eax，A的上下文)

上下文数据可以被丢弃吗？绝对不可以

当进程A暂时被切下来的时候，需要进程A顺便带走自己的上下文数据

环境变量

基本概念：

环境变量(environment variables)一般是指在操作系统中用来指定操作系统运行环境的一些参数

如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。

环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性

常见环境变量

PATH : 指定命令的搜索路径

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

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

查看环境变量方法

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

~/.bash_profile：用户级的环境配置文件，每个用户目录下都会具有各自的，在用户每次登录系统时被读取，里面所有命令都会被shell执行。包括环境变量的配置命令，因此A正确
~/.bash 以及 ~/bash 在linux的用户目录中默认是没有这两个文件的，因此也就不清楚其作用了，因此B和D都是错误的
/etc/progile.d 这是个目录或者说文件夹，其中包含了系统级的环境配置文件，任意用户登录时都会执行这个目录下的环境配置文件完成环境配置，但是要注意这个是目录并不是保存环境变量配置的配置文件，因此D错误

测试PATH

测试HOME

用root和普通用户，分别执行 echo $HOME ,对比差异

. 执行 cd ~; pwd ,对应 ~ 和

HOME 的关系

和环境变量相关的命令

echo: 显示某个环境变量值

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

env: 显示所有环境变量

unset: 清除环境变量

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

将我们的程序所在路径加入环境变量PATH当中，export PATH=$PATH:hello程序所在路径

环境变量在系统中是以key-value形式存储的，每一种环境变量都有各自的用途

环境变量的组织方式

每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以’\0’结尾的环境字符串

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

main函数可以带参吗？可以的话可以带几个？

main函数可以获取环境变量参数比如下面获取第三个参数的代码

直接在main函数命令行传参时导入

 #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;
 }

通过第三方变量environ获取

 #include<stdio,h>
 
 int main(int argc,char*argv[])
 {
     extern char**environ;//c语言提供的全局的变量，当程序启动时，这个指针就会指向我们的环境变量表
     int i=0;
     for(; environ[i];i++)
     {
         printf("%s\n",environ[i]);
     }
     return 0;
 }

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

那么argc和argv是什么呢？

argv 就是字符串数组，指向一个个参数
argc是argv数组长度

此程序逻辑：

如果argc是2(有一个命令，带一个参数)

判断对应的参数，执行对应的功能

命令行参数

意义在于同样的一个程序，通过选项的方式选择，使用同一个程序的不同子功能(即命令选项的底层用的都是用命令行参数完成的)，而参数是由父进程bash先拿到然后喂给你的子进程的。

通过系统调用获取或设置环境变量

putenv , 后面讲解

getenv , 本次讲解

 #include<stdio.h>
 #include<stdlib.h>
 int main()
 {
     printf("%s\n",getenv("PATH"));
     return 0;
 }

常用getenv和putenv函数来访问特定的环境变量。

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

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

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

 export MYENV="hello world"

程序地址空间

研究背景

kernel 2.6.32
32位平台

程序地址空间回顾

我们在讲C语言的时候，老师给大家画过这样的空间布局图

[0,3]GB:用户空间

[3,4]GB：内核空间

可是我们对他并不理解！

因为在栈上，因为栈向下增长，和堆向对而生

实验1：查看不同区域地址

myproc.c

运行结果：

可以看出地址的分布同与上图对应

实验2：栈和堆的地址分配方向

栈向下增长，堆向上增长

通过test stack addr 可以看到static修饰的变量被编译器放到了全局数据区
字面常量硬编码进代码区，代码是只读的，不可写入的，和字面常量一样，实际上他们的地址区域是在一起的
在32位下，一个进程地址空间，取值范围是0x0000 0000~ 0xFFFF FFFF
一般地址空间在linux下看比较规范
[0,3]GB:用户空间
[3,4]GB:内核空间

父子进程的变量是同一个地址，但是子进程修改变量值后两个进程获得的变量值不同！->说明代码写的是虚拟地址(线性地址，不是物理地址)

所以，几乎所有的语言，如果他有"地址"概念，这个地址一定不是物理地址，而是虚拟地址。

为什么操作一块地址只需要传起始地址？

答：一般malloc后申请的空间会比程序员要求的多，用来存申请空间的属性信息：

时间/大小

访问的相关权限属性(cookie)

进程地址空间

地址空间是一种内核数据结构，他里面至少有各个区域的划分

各个区域的起始地址，终止地址

地址空间和页表(用户级)是每一个进程都私有一份，只要保证每一个进程的页表，映射的是物理内存的不同区域，就能做到，进程之间不会互相干扰，保证进程之间的独立性(父进程和子进程的关系)
当我们的程序在编译的时候，形成可执行程序的时候，没有被加载到内存中的时候，请问，我们程序内部有地址吗？

答：有，可执行程序其实编译的时候，内部已经有地址了

地址空间不要仅仅理解为OS内部要遵守，其实编译器也要遵守，即编译器编译代码的时候，就已经给我们形成了各个区域代码区，数据区，...并且采用和linux内核中一样的编址方式，给每一个变量，每一行代码都进行了编址。故程序在编译的时候，每一个字段早已经具有了一个虚拟地址
程序内部的地址，采用的是编译器编译好的虚拟地址
当程序加载到内存的时候，每行代码，每个变量便具有了一个物理地址，但是mm_struct中填充的是编译器编好的虚拟地址，物理地址只有通过页表映射才能访问，cpu拿到的指令的地址也是虚拟地址，所以此处产生了一个疑问：
CPU和操作系统的边界划分在哪里？(小白疑问)