Linux进程概念

一.冯若依曼体系结构

输入设备 : 计算机最终的目的是为了解决人的问题，而想解决人的问题的前提是人要将相应的数据输入到计算机当中，所以需要有输入设备

输出设备 : 计算机需要将计算后的结果提供给人，所以需要有输出设备

运算器 : 对输入的数据进行运算(算数运算/逻辑运算)

控制器 : CPU的指挥控制中心

存储器(内存) : 由于输入输出设备相比于CPU的计算速度较慢，根据木桶原理，整体计算机的速度偏慢， 因此引入了存储器(内存)，内存的特点是比输入输出设备快，但比CPU慢，因为内存具有预装数据的能力，CPU向输入设备要数据时，输入设备会把一些数据加载到内存，之后读数据就可以从内存中读取了，减少了和输入设备交互的次数，且CPU在处理数据时输入设备也可以加载数据到内存

1). 在数据层面上，CPU只和内存打交道，外设只和内存打交道
2). 常见输入设备 : 键盘，网卡，硬盘，话筒，摄像头
3). 常见输出设备 : 显示器，音响，网卡，硬盘
4). 数据要处理及程序运行之前，必须预装载到内存中
5). 寄存器不仅仅在CPU中有，其他外设中也是有的
6). 各种硬件单元之间链接用的是总线(IO总线(外设和内存)，系统总线(内存和CPU))

当你打开qq窗口，给你的好友发消息，整个数据流动过程是怎样的呢?(传输文件把显示器改为硬盘同理)

你的信息首先被加载到内存中，CPU读取内存中的信息进行打包等处理形成报文再写回到内存中，内存将数据写到你的显示器和网卡上，你的qq窗口就出现了你发的消息，信息经过网卡发送到网络中，你的好友电脑的网卡收到了你发的消息，写到内存中，CPU读取内存中的信息进行解包等处理再写回到内存中，内存将数据写到你的好友的显示器上，你的好友的qq窗口就出现了你发的消息

当外设中有数据时，外设会给CPU发信号告知CPU数据来临，CPU再控制数据加载到内存

二.操作系统

概念

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

1). 内核（进程管理，内存管理，文件管理，驱动管理）
2). 其他程序（例如函数库，shell程序等等）

设计OS的目的

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

定位

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

如何理解 “管理”

1). 和我们直接沟通的人算不算真正意义上的管理者 ?
2). 我们在校期间，见到校长的次数应该很少，校长既然都没见过你，校长是怎么进行管理的呢 ?
3). 管理者进行管理是不是一定要亲临现场呢 ?

在学校一般有三种角色，学生，辅导员，校长，学生就是典型的被管理者，校长就是典型的管理者(做决策)，辅导员是执行者(执行决策)，校长做出一个决策，让辅导员去执行，如校长打算挑3个人去参加比赛，将决策传达给辅导员，让辅导员把学生们的在校表现拿出来做参考，最终校长根据学生在校表现选出来3人，让辅导员告知这3个学生去参加比赛，在这个过程中，校长并没有和学生直接沟通，即被管理者和管理者是不需要直接沟通的，且校长(管理者)做出一个决策，是根据信息(数据)而做的。辅导员所做的事情一方面是采集信息，另一方面去做具体的事情，但如果信息量太大了以后，校长就需要对数据进行分类，同类的数据放在一起，描述信息的过程实际上是构建数据结构的过程，组织信息的过程实际上是对数据结构的管理

校长相当于操作系统，学生相当于软件或硬件资源，辅导员相当于驱动的角色

计算机管理硬件
1). 描述起来，用struct结构体
2. 组织起来，用链表或其他高效的数据结构

三.进程

什么是程序?
程序是指存储在磁盘上的静态文件，是已经编译好的可执行文件(代码 + 数据)

ELF文件类型
(1). REL (Relocatable file)
(2). EXEC (Executable file)

目标文件/可执行文件的内容是什么?

(1). objdump命令 是用查看目标文件或者可执行的目标文件的构成的gcc工具。
(2). 程序指令 + 程序数据构成可执行文件/目标文件

(3).

概念

硬盘中的可执行程序运行起来(Windows中双击.exe文件，Linux中./)会被加载到内存当中，可执行程序被加载到内存中，实际上是把用户的代码和数据加载到内存中，运行起来的程序就叫做进程，而在我们的系统中可以同时存在大量的进程(Linux使用 ps axj 查看当前进程)，我们在开机时第一个启动的程序就是操作系统，操作系统所做的一个工作是进程管理，操作系统进行进程管理是先描述，后组织，描述过程中的结构体是PCB(进程控制块)，PCB结构体中存在该进程的各种信息，组织是对这些结构体进行管理

1). 进程大小 > 可执行程序大小 ，因为操作系统要给可执行程序加上内核数据结构，方便管理
2). 为什么会存在PCB ？因为操作系统进行管理要先描述进程的各种信息

(1). 进程是如何启动的?

#include<iostream>
using namespace std;
int main()
{
	cout<<"hello world"<<endl;
	return 0;
}

1). 246459进程是由 bash 程序启动的
2). 246459进程调用 clone 系统调用函数创建出 246528 进程
3). 246459进程调用 wait4 函数阻塞
4). 246528进程调用execve函数加载ELF可执行文件 test
[“./test”] 是命令行参数，0x5631d46c66a0 /* 23 vars */ 是环境列表，在Linux中，是供所有应用程序可以使用的公共数据
5). 加载所依赖的相关库文件
6). 进程调用系统函数write输出字符串"hello world\n"，上层应用函数是printf
7). 此时子进程246528调用系统函数exit_group(0)退出进程，0是进程退出码
8). 246459进程调用wait4回收退出的子进程

(2). 进程是如何结束的?
1). 调用exit_group()退出进程
2). 调用 exit() 或 _exit()退出进程
3). 进程收到中断信号
4). 运行到最后一行代码
(3). 进程运行时做了哪些事情?
(4). 进程结束时做了哪些事情?
(5). 进程运行时的内存数据在哪里?

echo $$ //  返回登录shell的PID
strace -f -s 65500 -T -o test.txt -p 进程id
// 在246459进程中启动 ./test

PCB

进程信息被放在一个叫做进程控制块的数据结构中，可以理解为进程属性的集合。
Linux操作系统下的PCB是: task_struct，task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息。

task_ struct内容分类

标示符: 描述本进程的唯一标示符，用来区别其他进程。
状态: 任务状态，退出代码，退出信号等。

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
	printf("main start\n");
	printf("main end");
	return 300; // 返回44,会 & 0xFF 作为返回结果,会刷新缓冲区
	exit(0);    // 会刷新缓冲区
	_exit(0);   // 不会刷新缓冲区
	_Exit(0);   // 不会刷新缓冲区
	abort();    // SIGABORT 信号
}

优先级: 相对于其他进程的优先级(谁先谁后拿到资源)。
为什么要有优先级?
因为资源有限，CPU资源是有限的，进程可以有多个，所以进程需要优先级设置

程序计数器: 程序中即将被执行的下一条指令的地址。
CPU取指令，分析指令，执行指令，当进程被切换后再被调度时，可以通过程序计数器再开始执行

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

时间片: 进程在CPU上运行的时间

上下文数据: 进程执行时处理器的寄存器中的数据。

I/O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表。
记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号等。
其他信息

标识符

首先认识一下getpid/getppid系统调用接口，分别获取该进程id和该进程的父进程id

// myproc.c内容

#include<stdio.h>
#include<unistd.h>
int main()
{
      while(1)
      {
            printf("I am a process,pid : %d,ppid : %d \n",getpid(),getppid());
            sleep(1);
      }
      return 0;
}

1). getpid用来获取当前进程的pid，getppid用来获取当前进程的ppid
2). 我们多次运行同一可执行程序，可以发现进程id每次是不一样的，但父进程ppid每次都是一样的，我们查看父进程会发现父进程为 bash 进程(登录成功时会创建一个bash进程，kill -9 ppid 会把bash进程杀死，导致登录窗口挂掉)

3).子进程终止或崩溃不会影响 bash 进程

// myproc.c的内容

#include<stdio.h>
int main()
{
       while(1)
       {
               printf("I am a process ,pid : %d ppid : %d\n",getpid(),getppid());
               int a = 1 / 0;  // 使进程崩溃
               sleep(1);
       }
}                  

4). 我们在登录服务器时会自动创建bash进程，ps axj | grep bash 如果发现有多个bash进程，说明服务器有多人正在使用，杀掉bash进程自动退出登录

5). 在根目录下有一个 proc 的目录，我们可以使用 ls /proc 查看所有进程，也可以查看某个进程具体的信息

ls/proc/进程pid 查看某个进程的详细信息，由此可知，进程是知道自己所处的工作目录的

状态

1). main函数里的 return 0 是给谁返回的? 为什么main函数要有返回值 ?

答 : 因为main函数最终是被操作系统调用的，所以是返回给操作系统的(把返回值数据保存在系统级别的某些变量中，然后修改 task_struct 的 exit_code)，main函数的返回值实际上就是退出码

(1). 进程创建的目的是为了帮助我们完成某种任务，那么当任务完成时，调用者需要关心任务完成的怎么样(我们可以通过查看进程的退出码)

看如下代码，当该进程被执行完后，我们怎么知道运算结果是否正确呢?

#include<stdio.h>
int main()
{
	int a = 30 + 40;
	if(a == 70)
		return 0;
	else
		return -1;
}

在这里给大家介绍一下 echo $?，该命令可以显示命令行中最近一次进程退出时的退出码，这就说明该进程运算结果是正确的

2). 我们需要通过某种状态信息来描述一个进程退出时的状态

一般一个进程退出时的状态分为3种 :

(1). 一个进程结束了(代码没有语法错误)，它的运算结果是正确的
(2). 一个进程结束了(代码没有语法错误)，它的运算结果是错误的(计算逻辑错误)
(3). 进程在代码执行期间崩溃了(代码有语法错误)

3). 当一个进程正在运行时，有的进程可能在运行状态，有的进程可能在休眠状态，有的进程可能在暂停状态，有的进程可能在新建或者就绪状态，这些也是状态信息(就绪，新建，运行，挂起，阻塞等待，退出)

4). 进程状态是可以数据化的(例如，0表示运行状态，1表示休眠状态)

以上的这些状态信息都被记录在PCB结构体当中

R（TASK_RUNNING）状态

只有在该状态的进程才可能在CPU上运行，如果只有一个单核CPU，可以同时存在多个R状态的进程，进程是R状态，不代表正在运行，而代表该进程可被调度，其他状态的进程如果想被调度，一定要将状态设置成R状态

多个R状态的task_struct会被连接到一起，称为调度队列(遵循FIFO原则)，操作系统想要调度进程，会从调度队列中选择进程去调度

S（TASK_INTERRUPTIBLE）状态

可中断的睡眠状态(浅度睡眠状态)，进程可以被杀死

处于这个状态的进程因为等待某某事件的发生（比如等待socket连接、等待信号量），而被挂起。这些进程的task_struct结构被放入对应事件的等待队列中。当这些事件发生时（由外部中断触发、或由其他进程触发），对应的等待队列中的一个或多个进程将被唤醒。

通过ps命令我们会看到，一般情况下，进程列表中的绝大多数进程都处于TASK_INTERRUPTIBLE状态（除非机器的负载很高）。毕竟CPU就这么一两个，进程动辄几十上百个，如果不是绝大多数进程都在睡眠，CPU又怎么响应得过来。

// myproc.c 内容

#include<stdio.h>
#include<unistd.h>
int main()
{
     while(1)
     {
        printf("process is running\n");
        sleep(100);
        printf("process is sleeping\n");
     }
}
// 该进程为休眠状态
2262   2396   2396   2262 pts/0      2396 S+    1000   0:00 ./myproc

D状态(TASK_UNINTERRUPTIBLE)

不可中断的睡眠状态(深度睡眠状态），不能被杀死

D状态存在的意义就在于，内核的某些处理流程是不能被打断的

内存中的一个进程想要把一些数据存到磁盘上，磁盘接到命令后，就去存储数据了，进程就开始等待磁盘存储数据的结果(即进程处于休眠状态)，但在这时，操作系统发现该进程在休眠状态，而这时内存已经严重不够了，于是操作系统将该进程杀掉了，可是磁盘存储数据失败了，磁盘向进程反馈存储失败的结果，可该进程已经被杀死了，无法给磁盘做出响应，于是造成磁盘陷入不可控的状态

因此我们可以将该进程设置为D状态，于是该进程不响应异步信号，kill -9就杀不死这个进程了！

T状态(TASK_STOPPED or TASK_TRACED)

暂停状态或跟踪状态

向进程发送一个SIGSTOP信号，它就会因响应该信号而进入TASK_STOPPED状态(除非该进程本身处于TASK_UNINTERRUPTIBLE状态而不响应信号)

向进程发送一个SIGCONT信号，可以让其从TASK_STOPPED状态恢复到TASK_RUNNING状态

// myproc.c 内容

#include<stdio.h>
#include<unistd.h>
int main()
{
        while(1)
        {
                printf("I am a process,pid : %d,ppid : %d\n",getpid(),getppid());
                sleep(1);
        }
}

kill -l 显示系统信号集

1~34为普通信号，35 ~ 64 为实时信号

当进程处于暂停状态时，给进程发信号进程不会响应信号，等到唤醒后才会处理信号

Z状态(TASK_DEAD - EXIT_ZOMBIE)

退出状态，进程成为僵尸进程，进程在退出的过程中，处于TASK_DEAD状态。

(1). 僵死状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用）没有读取到子进程退出的返回代码时就会产生僵死(尸)进程

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

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

在这个退出过程中，进程占有的所有资源将被回收，除了task_struct结构（以及少数资源）以外。于是进程就只剩下task_struct这么个空壳，故称为僵尸。

之所以保留task_struct，是因为task_struct里面保存了进程的退出码、以及一些统计信息。而其父进程很可能会关心这些信息。(父进程读取完这些信息，task_struct 结构体会被释放掉)

至于为什么要存在僵尸进程?我们在开头已经做好了铺垫

进程创建的目的是为了帮助我们完成某种任务，那么当任务完成时，调用者需要关心任务完成的怎么样(我们可以通过查看进程的退出码及一些退出信息)

// 僵尸进程代码

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
        printf("I am running\n");
        pid_t pid = fork();
        // 子进程
        if(pid == 0)
        {
                int count = 5;
                while(count--)
                {
                        printf("I am a child,pid : %d,ppid : %d,count : %d\n",getpid(),getppid(),count);
                        sleep(1);
                }
                printf("child quit.....\n");
                exit(1);
        }
        // 父进程
        else if(pid > 0)
        {
                while(1)
                {
                        printf("I am a father,pid : %d,ppid : %d\n",getpid(),getppid());
                        sleep(1);
                }
        }
        return 0;
}

while :;do ps axj | head -1 && ps axj | grep myproc | grep -v grep;echo "#########################";sleep 1;done

僵尸进程危害

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

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

(3).那一个父进程创建了很多子进程，就是不回收，就会造成内存资源的浪费，因为数据结构
对象本身就要占用内存，因此就造成了内存泄露

孤儿进程

当一个进程的父进程退出了，而这个进程还在运行，这个进程就叫做孤儿进程，当该进程也退出时，该进程成为僵尸进程，但其父进程已经退出，没有进程来回收它，就会导致内存泄露的问题，操作系统肯定是不允许这样的情况发生，所以当一个进程的父进程退出后，该进程会被init进程（init进程的pid为1）领养，当该进程退出后，由 init 进程来回收它

// myproc.c 内容

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
int main()
{
       printf("I am running\n");
       pid_t pid = fork();
       if(pid == 0)
       {
        while(1)
        {
                printf("I am a child,pid : %d,ppid : %d\n",getpid(),getppid());
                sleep(1);
        }
       }
       else if(pid > 0)
       {
        int count = 5;
        while(count--)
        {
                printf("I am a father,pid : %d,ppid : %d\n",getpid(),getppid());
                sleep(1);
        }
        exit(0);
       }
 }                           

由运行结果可以看到，当父进程退出以后，子进程的 ppid 变为了 1，且由前台进程变成了后台进程

前台进程和后台进程

在Linux命令行中只能有一个前台进程，如果你的进程是前台进程，那么输入命令行是无效的，而后台进程有多个，因此不影响命令行的输入，想把前台进程变为后台进程，在后面加 & (杀掉后台进程使用kill -9 pid) （前台进程 R+，后台进程 R）

优先级

优先级是指谁先谁后拿到某种资源，和权限有所不同的是，权限是指能不能做某事，存在优先级的原因是因为资源有限，CPU资源是有限的，而进程是可以有多个的，因此进程需要进行优先级设置(让进程在各自特定的时间段内和CPU交互)。

调度 : 操作系统从多个进程当中选择一个进程放到CPU上

在Linux中，使用 ps -l (或 ps -al)查看系统进程

以上列表的信息含义如下 :

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

PRI/NI

(1). PRI，即进程的优先级，或者通俗点说就是进程被CPU执行的先后顺序，此值越小进程的优先级别越高

(2). NI，进程的nice值，其表示进程可被执行的优先级的修正数值

(3). PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice
这样，当nice值为负值的时候，那么该进程将会优先级值将变小，即其优先级会变高，则其越快被执行，所以，调整进程优先级，在Linux下，就是调整进程nice值

(4). nice其取值范围是-20至19，一共40个级别。

(5). Linux下默认 PRI 为 80，NI 为 0

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

(1). top
(2). 进入top后按“r”–>输入进程PID–>输入nice值
(3). q 退出

注意 : 每次更改nice值，PRI 都会从默认值80开始加上nice值得到新的PRI，更改nice值的过程中如果超过了nice值的范围，会按边界值进行计算(即最大为19，最小为-20)

并行并发概念

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

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

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

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

程序计数器

CPU内部架构和工作原理

时间片 : CPU分配给各个进程的时间，即该进程允许运行的时间

每个运行的进程，都有自己的 “时间片”

在任何一个时间段内，一个CPU上跑的只能有一个进程，当时间段(时间片)到了之后，进程会自己主动或者被操作系统被动的剥离下CPU，操作系统再去调度其他的进程放到CPU上。

在时间段内，CPU会执行进程的代码(默认情况下代码是从上向下执行的)，CPU执行代码的过程可分为3部分，取指令，分析指令，执行指令，CPU内部有一个eip的寄存器(指令计数器)，保存的是程序中即将执行的下一指令的地址，例如，CPU取完第1行的指令，分析执行完第一行指令后，eip里更新为第2行指令的地址，下次CPU取指令时就从eip寄存器中得到第二行指令的地址，分析执行完第二行指令后，eip寄存器自动更新成第三行指令的地址，以此类推

由上可知，所谓的函数跳转，分支判断，循环等，都是通过修改eip来完成的，这个eip就称为当前进程的程序计数器

上下文数据

当一个进程在运行的过程中，由于某种原因导致进程被切换了[进程被切换，可能在任何时间点(时间片到了或当前进程被抢占等等)]但进程还没有被执行完，那么该进程所产生的数据要怎么处理呢?

我们都知道，CPU在执行进程时，会将进程的数据暂存到CPU的存储单元的寄存器当中，然后再由运算单元根据控制单元传来的命令去进行相应的运算，最后将结果再写回到内存当中，我们把CPU存储单元的寄存器里面所暂存的数据就叫做上下文数据

如果该进程被切换后，数据就被下一进程覆盖掉了，那当再次轮到该进程执行时，还需要从头开始执行，这显然是效率很低的，所以我们需要将进程的上下文数据进行保存，当再次轮到该进程执行时，根据保存的上下文数据从上次执行的位置接着往下执行。

上下文数据会被保存到进程控制块当中(Linux下为 task_struct，程序计数器也属于上下文信息)

通过系统调用创建进程

fork()初识

1). fork()函数用来创建进程，fork()之前的代码被父进程执行，fork()之后的代码，父子都可以执行

// myproc.c 内容

#include<stdio.h>
#include<unistd.h>
int main()
{
		// fork()之前的代码被父进程执行
        printf("I am running\n");
        fork();
        // fork()之后的代码，父子都可以执行
        while(1)
        {
                printf("I am a process,pid : %d,ppid : %d\n",getpid(),getppid());
                sleep(1);
        }       
}

运行结果

I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309  // 3310就是fork()出来的子进程
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309
I am a process,pid : 3309,ppid : 2188
I am a process,pid : 3310,ppid : 3309

2). fork()之后，父子进程代码共享，数据各自开辟空间，私有一份(采用写是拷贝)

3). fork()之后，就有了两个进程，这两个进程谁先被调度?
答案是不确定的，两个进程被调度的顺序完全是由操作系统的调度算法决定的

4). fork()函数会有两个返回值，给父进程返回子进程pid，给子进程返回0，创建进程失败返回-1

// myproc.c 内容

#include<stdio.h>
#include<unistd.h>
int main()
{
        printf("I am running\n");
        pid_t id = fork();

        printf("pid : %d\n",id);
        sleep(1);
}

运行结果

I am running
pid : 3979
pid : 0

5). fork()函数的常见使用

#include<stdio.h>
#include<unistd.h>
int main()
{
        printf("I am running\n");
        pid_t id = fork();
        // 子进程
        if(id == 0)
        {}
        // 父进程
        else if(id > 0)
        {}
        // 创建进程失败
        else
        {}
}

vfork() : 创建子进程并阻塞父进程，父子进程共享同一块内存地址空间(子进程做的任何修改父进程都能看到)

四. 环境变量

命令行参数

打印命令行参数和环境变量
#include<iostream>
using namespace std;
int main(int argc,char* argv[],char* envp[])
{
	cout<<argc<<endl;
	while(argv)
	{
		cout<<*agrv++<<endl;
	}
	while(envp)
	{
		cout<<*envp++<<endl;
	}
	return 0;
}

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

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

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

PATH

PATH这个环境变量是系统自带的，它的含义就是系统在查找可执行程序会搜索的路径和范围

不知道我们有没有注意到这个问题，我们在运行起自己的程序时，需要加 ./ ，但运行系统的命令时，却不需要 ./ ，这就是因为环境变量的原因

(1). 我们要知道，系统想要执行一个指令，必须先要找到这条指令，再将其运行起来，而对于我们自己写的程序，系统是不知道这条指令的位置的，所以要加上 ./ 告知系统程序在当前目录下

(2) . 像 ls ,pwd 等系统指令之所以能够直接使用，是因为系统会去环境变量PATH中去查找

// 可以查看 PATH 环境变量中的内容
echo $PATH

(3). 如果你想要让自己写的程序不用加 ./ 就可以运行起来，有两种方法

第一种方法 : 将自己写的程序加到PATH中的某个路径下

sudo cp -f myproc /usr/bin

第二种方法 : 把我们当前所处的路径导到PATH中

export PATH=$PATH:当前路径

(4). 我们可以把PATH环境变量置为空，这是我们发现系统命令大部分就不能使用了(pwd命令还可以使用，因为有PWD环境变量保存当前路径)，但不用担心，我们退出登陆后，再次登录就会发现PATH环境变量会恢复回来，说明PATH环境变量是在系统配置文件中(.bashrc)写的。

export PATH=

HOME

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

普通用户和 root 用户

SHELL

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

bash实际上是一个进程，用来解释我们的指令(命令行解释器)

和环境变量相关的命令

(1). echo: 显示某个环境变量值
(2). export: 设置一个新的环境变量(自己设置的环境变量退出后再次登录就无了)

导出环境变量

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

向当前终端发送信息 :

向其他终端发送信息 :

(4). unset: 清除环境变量

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

我们也可以自己定义本地变量(只在本进程(bash)内有效)，使用 set 查看

环境变量的组织形式

我们应该先知道一件事情，main函数也是带参数的，虽然我们写代码时基本不带参数，但我们借助vs调试里的调用堆栈窗口就可以看到main函数是被mainCRTStartup函数调用的，而mainCRTStartup函数又是被操作系统调用的

main函数的三个参数分别为 argc(命令行参数个数)，argv(命令行参数列表)，envp(环境变量)

这样我们就可以让一个程序根据命令行参数的不同来进行不同的操作（类比一个指令根据选项不同可以执行不同的操作)

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

环境变量是一个系统级别的全局变量，bash之下所有进程都可以获取

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

获取环境变量

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

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

getenv 函数简介

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

五.进程地址空间

进程地址空间的分布如下图 :

下面我们来用一段代码来验证一下上图的布局

#include<stdio.h>
#include<malloc.h>
#include<string.h>
int g_unval;
int g_val = 100;
int main(int argc,char* argv[],char* envp[])
{
        printf("code addr : %p\n",main);  // 代码段
        char* str = "hello world";       
        printf("read only addr : %p\n",str); // 常量区
        printf("init addr : %p\n",&g_val);  // 已初始化的全局变量
        printf("uninit addr : %p\n",&g_unval); // 未初始化的全局变量

        int* p = malloc(20);
        printf("heap addr : %p\n",p);  // 堆区

        printf("stack addr : %p\n",&str); // 栈区
        printf("stack addr : %p\n",&p);  // 栈区

        for(int i = 0;i < argc;i++)
        {
                printf("argc addr : %p\n",argv[i]); // 命令行参数
        }
        int i = 0;
        while(envp[i])
        {
        	printf("envp addr : %p\n",envp[i]);  // 环境变量
        	i++;
        }
}                            

由运行结果我们可以看出 代码段，常量区，已初始化全局变量，未初始化全局变量，堆区，栈区，命令行参数，环境变量 的地址依次增大，符合我们上图的结论

但是我们真的了解它吗?，我们来研究一下下面的两段代码

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 100;
int main()
{
        pid_t id = fork();
        if(id < 0)
        {
                 perror("fork");
                 return 0;
        }
        else if(id == 0)
        { //child
                 printf("child : pid : %d ,ppid : %d,g_val : %d,&g_val : %p\n", getpid(), getppid(),g_val,&g_val);
        }
        else
        { //parent
                 printf("father : pid : %d ,ppid : %d,g_val : %d,&g_val: %p\n", getpid(), getppid(),g_val,&g_val);
        }
         sleep(1);
         return 0;
}                                                                                                                                                                    

这份代码可能同学们觉得理所当然，因为子进程按照父进程为模版，父子并没有对变量进行进行任何修改

那我们接着看下一段代码

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int g_val = 100;
int main()
{
        pid_t id = fork();
        if(id < 0)
        {
                 perror("fork");
                 return 0;
        }
        else if(id == 0)
        { //child
        		g_val = 200;
                 printf("child : pid : %d ,ppid : %d,g_val : %d,&g_val : %p\n", getpid(), getppid(),g_val,&g_val);
        }
        else
        { //parent
        		sleep(2);
                 printf("father : pid : %d ,ppid : %d,g_val : %d,&g_val: %p\n", getpid(), getppid(),g_val,&g_val);
        }
         sleep(1);
         return 0;
}                                          

我们可以发现，父子进程输出的地址是一致的，但是变量的内容不一样，这就说明 :

(1). 该地址绝对不是物理地址，这种地址叫做虚拟地址
(2). 我们在用C/C++语言所看到的地址，全部都是虚拟地址！物理地址，用户一概看不到，由OS统一管理，OS必须负责将 虚拟地址 转化成 物理地址 。
(3). 每个进程都有自己的进程地址空间，这也体现了进程的独立性(物理空间上的独立)

接下来我们来分析一下这两段代码的结果
首先，由于子进程是以父进程为模板的，所以最开始子进程创建时，子进程的虚拟内存映射到物理内存的代码和数据和父进程的虚拟内存映射到物理内存的代码和数据是一样的.

然后，子进程对g_val进行修改，但由于进程具有独立性，子进程对g_val的修改不能影响父进程的g_val，所以子进程会改变映射关系，映射到与父进程不同的物理内存中，这就出现了虚拟地址相同，物理地址不同的现象，父进程和子进程就在数据层面发生了分离，这种写入时再发生内存重新申请的现象叫做写时拷贝

(1). 进程地址空间本质上是内存中的一种内核数据结构，实际上，进程地址空间是我们人为抽象出来的，在mm_struct结构体中，用多个无符号整形来划分各种区域，例如 [start_code,end_code]表示代码区的区域

(2). 我们平时所说的栈向下生长，堆向上生长是怎么做到的 ?

通过调整栈区的末尾使stack_end减小，调整堆的heap_end使heap_end增大

(3). 为什么要有进程地址空间?

1).不会有任何系统级别的越界问题存在了(进程地址空间 + 页表本质功能之一 : 保护物理内存)
2). 每个进程都认为看到的是相同的空间范围(构成，顺序)
3). 每个进程都认为自己在独占内存，更好的完成进程独立性以及合理的使用空间(进程调度和内存管理进行解耦)