文章目录

进程基本概念
描述进程-PCB
- task_struct-PCB的一种
- task_ struct内容分类
组织进程
查看进程
通过系统调用获取进程标示符
fork创建子进程
进程状态
- 操作系统原理进程状态
- linux进程状态
优先级
- 基本概念
- 查看系统进程
- PRI and NI
- 查看进程优先级的命令
- 其他概念
环境变量
- 基本概念
- 常见环境变量
- 查看环境变量方法
- 测试HOME
- 和环境变量相关的命令
- 模拟实现指令+选项
- 环境变量的组织方式
- 通过代码如何获取环境变量
- 环境变量通常具有全局属性
程序地址空间
- 验证程序地址
- - 验证程序地址空间排布
  - 验证堆和栈增长方向
  - 如何理解static变量
- 感知地址空间的存在
- 页表&虚拟地址空间

进程基本概念

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

简单来讲进程：PCB（task_struct） + 进程代码和数据

描述进程-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这些用户级工具来获取

ps ajx | head -1 && ps axj | grep 'test' | grep -v grep

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

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

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

如果多执行几次就会发现，每次子进程id（pid）会有所差异

而父进程id（ppid）不变，是谁呢？是bash

几乎我们在命令行上所有的指令（包括你的cmd），都是bash进程的子进程

fork创建子进程

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
int main()
{
    int id = fork();
    printf("hello proc : %d!, id: %d\n", getpid(), id);
    sleep(1);
    return 0;
}

代码创建子进程的各种困惑解答：

fork函数是用来创建子进程的，它有两个返回值。父进程返回子进程pid，子进程返回0

同一个id值，使用打印，没有修改，却打印出了不同的值。这个讲到进程地址空间再解释

为什么fork要有两个返回值，父进程返回子进程pid，子进程返回0

父亲有多个儿子

父进程必须有标识子进程的方案，fork之后，给父进程返回子进程的pid

子进程最重要的是知道自己被创建成功了，因为子进程找父进程的成本低（子进程只有一个父进程），就返回个0表示一下自己被创建成功就行了

如何创建子进程

fork之后，系统多了一个进程

task_struct + 父进程代码和数据

新增了：task_struct + 子进程代码和数据

子进程task_struct对象内部数据从哪里来，基本是从父进程那里继承下来的

子进程执行代码，计算数据，子进程的代码从哪里来呢，是和父进程执行相同的代码，fork之后父子进程代码共享（可以通过不同的返回值，让不同进程执行不同代码），而数据要各自独立（虚拟地址空间，之后再说）

如何理解进程被运行

每个CPU都拥有一个运行队列（runqueue），队列里装的是每个进程的task_struct，每个task_struct都有指向它的代码和数据，供CPU去调度运行

fork怎么返回两次

在执行fork函数中的返回语句return之前，该干的都干完了。已经创建了子进程，并将它放入运行队列中准备运行，之后父子进程代码共享，都会执行return语句，就拥有了两个返回值

进程状态

进程状态存在task_struct里

操作系统的书里会列举各种抽象概念，这些概念是为了，抽象地总结各个操作系统的特点，这固然很正确，但对学习者不太友好。在这里我们反过来，用linux的特点，来理解操作系统的抽象概念

操作系统原理进程状态

运行态：只要进程在运行队列里就叫运行态（并不意味着进程一定在运行中，而是表示此进程准备就绪，随时可以调度）
终止态：进程还在，只是之后不再运行了，随时等待被释放（进程都终止了，为什么不立刻释放对应资源，而要维护一个终止态？释放也要花费时间，说不定当前操作系统很忙，来不及释放呢）
阻塞态：进程等待某种资源（非CPU），资源没有就绪，进程需要在该资源的等待队列排队，此时进程代码没有运行，进程所处的状态叫阻塞态
一个进程在使用资源时，不仅仅是在申请CPU资源。进程可能申请更多其他资源：网卡、显卡、磁盘……
如果我们申请CPU资源，暂时无法得到满足，是需要排队的——运行队列
如果我们去申请其他慢设备资源呢——也是需要排队的（进程在排队）
当进程访问某些资源（磁盘、网卡），但该资源暂时没有准备好，或者正在给其他进程提供服务。此时，当前进程要从运行队列中移除，并将它放到对应设备的描述结构体中的等待队列里（这是由操作系统管理的）
当我们的进程在等待外部资源时，该进程的代码不会被执行，我的进程被卡住了——进程堵塞

挂起态：
硬盘数据要加载到内存中
内存大小是有限的，内存不足的话，操作系统要帮我们调度资源
短期内不会被调度的进程，它的代码和数据存放在内存中就是浪费空间，操作系统会把该进程的代码和数据置换到硬盘中，此时task_struct大概率还在内存中，而它的代码和数据会被释放（往往内存不足伴随着硬盘的高频率访问）

linux进程状态

Linux内核源代码

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的结束。在linux中，如果等待的是磁盘资源，我们进程阻塞所处的状态是D状态。
T停止状态（stopped）：可以通过发送 SIGSTOP（kill -19）信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT （kill -18）信号让进程继续运行。
t停止状态（tracing stop）：进程被调试时，遇到断点所处的状态
X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
Z僵尸状态（zombie）：一个linux进程退出时，不会立刻进入X状态（死亡，资源可以立刻回收），而是进入Z状态
- 为什么要进入Z状态？进程是用来执行任务的，当进程退出时，我们要得到它的任务反馈。Z状态就是为了维护退出信息，可以让父进程或OS读取（是通过进程等待来读取的，如何等待，我们后面讲）
- 如何模拟僵尸进程：只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态
- 僵尸进程危害：
  进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态
  维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说， Z状态一直不退出， PCB一直都要维护
  那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费，导致内存泄漏。一般必须要求父进程回收，我们后面讲

进程运行对应R运行状态

进程终止对应X死亡状态或Z僵尸状态

进程阻塞对应S睡眠状态或D磁盘休眠状态

进程挂起对应S睡眠状态或D磁盘休眠状态或T/t停止状态

孤儿进程：父进程先退出，子进程就称之为“孤儿进程”
- 如果父进程提前退出，子进程后退出，进入Z之后，那该如何处理呢？
- 孤儿进程被1号进程（操作系统）领养，当然就由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个级别。

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

查看进程优先级的命令

用top命令更改已存在进程的nice：
top
进入top后按“r”–>输入进程PID–>输入nice值

其他概念

竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级
独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰
并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行
并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发
进程抢占：低优先级进程正在运行，如果来了个优先级高的进程，调度器会直接把进程从CPU上剥离，放上优先级高的进程
进程的优先级队列：系统允许不同优先级的进程存在，并且相同优先级的进程可能存在多个，为了更好调度不同优先级的进程（队列是绝对的先进先出，单个队列没法实现进程抢占）。我们根据不同优先级，将特定的进程放到不同的队列中
进程间切换：
- CPU内的寄存器可以临时存储数据（非常少，但非常重要）。
- 当进程再次被执行时，一定会存在大量的临时数据暂存在CPU内的寄存器中。我们把进程在运行中产生的各种寄存器数据，叫做进程的硬件上下文数据
- 当进程被剥离：需要保存上下文数据（保存在task_ struct里）
- 当进程恢复时：需要将曾经保存的上下文数据恢复到寄存器中

环境变量

基本概念

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

常见环境变量

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

查看环境变量方法

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

测试HOME

用root和普通用户，分别执行 echo $HOME ,对比差异
执行 cd ~; pwd ,对应 ~ 和 HOME 的关系

和环境变量相关的命令

echo: 显示某个环境变量值
export: 设置一个新的环境变量
env: 显示所有环境变量
unset: 清除环境变量
set: 显示本地定义的shell变量和环境变量

模拟实现指令+选项

为什么有些指令可以直接执行，不需要带路径，而我们的二进制程序需要带路径才能执行？因为我们的程序所在路径没有加入环境变量PATH。还有一个问题，指令的选项是如何让指令实现不同的功能的？

我们给main函数传递的argc，char*argv[]，命令行参数传递的是：命令行中输入的程序名和选项

同一个程序，通过传递不同的参数，让同一份程序有不同的执行逻辑，执行结果，就是这样实现的

int main(int argc, char*argv[])
{
	if(argc != 4)
    {
        printf("Usage: %s [-a|-s|-m|-d] one_data two_data\n", argv[0]);
        return 0;
    }
    int x = atoi(argv[2]);
    int y = atoi(argv[3]);
    if(strcmp("-a", argv[1]) ==0)
    {
        printf("%d+%d=%d\n",x, y, x + y);
    }
    else if(strcmp("-s", argv[1]) ==0)
    {
        printf("%d-%d=%d\n",x, y, x - y);
    }
    else if(strcmp("-m", argv[1]) ==0)
    {
        printf("%d*%d=%d\n",x, y, x * y);
    }
    else if(strcmp("-d", argv[1]) ==0 && y != 0)
    {
        printf("%d/%d=%d\n",x, y, x / y);
    }
    else
    {
        printf("Usage: %s [-a|-s|-m|-d] one_data two_data\n", argv[0]);
    }
}

环境变量的组织方式

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

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

方法一：命令行第三个参数

#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;
    int i = 0;
    for(; environ[i]; i++){
    	printf("%s\n", environ[i]);
    }
    return 0;
}

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

方法三：通过系统调用获取环境变量

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

为什么我们要获取环境变量：为了实现一些特殊用法。例如：只允许特定用户访问文件

int main()
{
    char *id = getenv("USER");
    if(strcasecmp(id, "tyyg") != 0)
    {
        printf("权限拒绝!\n");
        return 0;
    }
    printf("成功执行\n");
}

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

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

本地变量：在bash内部定义的变量（声明时不带export），不会被子进程继承下去

特殊情况：Linux下大部分命令都是通过子进程的方式执行的。但是还有一部分命令，不通过子进程的方式执行，而是由bash自己执行（调用自己对应的函数来完成特定的功能），我们把这种命令叫内建命令

例如：创建本地变量后，用echo$来访问本地变量（这里echo不是子进程）

程序地址空间

程序地址空间（进程地址空间）不是内存，进程地址空间是操作系统上的概念

验证程序地址

验证程序地址空间排布

int un_g_val;
int g_val = 10;  

int main(int argc, char* argv[], char* env[])
{
     printf("code addr          : %p\n", main);
     printf("init global addr   : %p\n", &g_val);
     printf("uninit global addr : %p\n", &un_g_val);
     char* m = (char*)malloc(100);
     printf("heap addr          : %p\n", m);
     printf("stack addr         : %p\n", &m);
     for(int i = 0;i<argc;i++)
     {
         printf("argv addr          : %p\n", argv[i]);
     }
 
     for(int i = 0;env[i];i++)
     {
         printf("env addr           : %p\n", env[i]);
     }
}

验证堆和栈增长方向

堆区向地址增大方向增大

栈区向地址减小方向增大

如何理解static变量

写在函数内的变量，一般是存在栈上的，后定义的变量地址低

函数内定义的变量用static修饰，本质是编译器会把该变量编译进全局数据区。生命周期和全局变量一样

感知地址空间的存在

int g_val=100;

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //child
        int flag = 0;
        while(1)
        {
            printf("我是子进程:%d, ppid: %d, g_val: %d, &g_val: %p\n\n", getpid(), getppid(), g_val, &g_val);
            sleep(1);
            flag++;
            if(flag == 5)
            {
                g_val=200;
                printf("我是子进程，全局数据我已经改了，用户你注意查看！\n");
            }
        }
    }
    else 
    {
        //parent
        while(1)
        {
            printf("我是父进程:%d, ppid: %d, g_val: %d, &g_val: %p\n\n", getpid(), getppid(), g_val, &g_val);
            sleep(2);
        }
    }
}

父子进程读取同一个变量（变量地址一样），但是后续没有人为修改的情况下，父子进程读取到的内容是不一样的！

我们在C/C++中使用的地址，不是物理地址！（如果是物理地址，这种现象不可能产生）

这种地址是：虚拟地址，线性地址，逻辑地址

为什么操作系统不让我直接看到物理内存呢？

内存就是一个硬件，不能阻拦你访问，只能被动地进行读取和写入（如果直接访问内存，你能修改所有内容，太不安全了）。

进程地址空间：每个进程在启动的时候，都会让操作系统给他创建一个地址空间，该地址空间就是进程地址空间

每个进程都有一个自己的进程地址空间，操作系统要管理这些地址空间（先描述，再组织）。

进程地址空间，其实是内核的一个数据结构，struct mm_struct

究竟什么是地址空间

进程具有独立性：进程相关的数据结构是独立的，进程的代码和数据是独立的

OS通过软件的方式，给进程一个软件视角，认为自己会完整地独占系统中的所有资源，方便管理

页表&虚拟地址空间

程序被编译出来，没有被加载的时候，程序内部已经有地址（链接时需要地址）和区域了。

将程序加载到内存，由程序变成进程后，程序的虚拟地址和在内存中的真实地址是有出入的，所以操作系统给每个进程构建一个页表结构，构建映射关系，以联系两个地址关系，方便CPU通过虚拟地址找到内存数据

进程是独立的。创建子进程之初，父子进程共享代码和数据。但当子进程想要修改数据时，会发生写实拷贝，给子进程在内存里开辟一段空间存储修改后的数据（以维持父进程数据不被子进程改变），此时子进程的页表映射关系改变，但地址空间的地址不变

通过上图很容易理解：同一个变量，地址相同，其实是虚拟地址相同，内容不同其实是被映射到了不同的物理地址

简单类比一下。虚拟地址空间：摩斯电码；页表：摩斯密码对照表；物理内存：解码后的真实语句

我们回过头解释之前的遗留问题：fork有两个返回值，pid_t pid，同一个变量，使用打印，没有修改，为什么打印出了不同的值？

pid_t id是属于父进程栈空间中定义的变量，fork内部，return会被执行两次，return的本质，就是通过寄存器将返回值写入到接受返回值的变量中

当id=fork()的时候，谁先返回，谁就要发生写时拷贝，所以，同一个变量，会有不同的内容值，本质是因为大家的虚拟地址是一样的，但是大家对应的物理地址是不一样的

为什么要有虚拟地址空间？

保护内存。如果有野指针，页表没法实现映射关系，就不会影响物理内存。虚拟地址空间给访问内存添加了一层软硬件层，可以转化过程进行审核，能够拦截非法访问
将Linux内存管理，进程管理通过地址空间，进行功能模块的解耦。如果你要空间，我就在地址空间里给你扩大空间，但在你要实际使用访问时，我才在内存里开辟空间给你用。
让进程或者程序可以用一种统一的视角看待内存。方便以统一的方式来编译和加载所有的可执行程序，简化进程本身的设计与实现