Liunx 操作系统 进程概念（下）

一.命令行参数和环境变量

1.环境变量的概念

环境变量（Environment Variables）可以理解成：

操作系统提前准备好的一些“全局配置信息”，程序运行时可以读取这些信息。

例如：

echo $PATH

就是查看PATH环境变量。

可以把环境变量想象成：

操作系统 | |--- PATH |--- HOME |--- SHELL |--- ...

不同程序都可以读取这些信息。

2.常见环境变量

1. PATH

PATH：指定命令的搜索路径。

当我们在终端输入一条命令（例如ls、python或java）时，操作系统并不会立刻知道该命令对应的程序存放在哪里。它会按照PATH环境变量中记录的目录顺序，依次去这些目录里查找是否存在同名的可执行文件。一旦找到，就立即执行；如果所有目录都找遍了仍然没有，终端就会提示command not found（命令未找到）。

例如，当我们执行echo $PATH时，通常会看到类似下面这样的输出：

/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

这里每一段路径之间用冒号（:）分隔，表示系统会按照从左到右的顺序依次在这些目录中搜索命令。这种设计带来的好处是：我们不需要记住每个程序安装的完整路径，只要把它的目录加入PATH，就可以在任何位置直接输入命令名来启动它。

在实际开发中，我们经常需要修改PATH。比如安装了某个新工具后，如果直接运行命令提示找不到，通常就是因为它的安装目录还没有被加入PATH。此时可以在终端中临时追加路径，例如：

export PATH=$PATH:/自定义/工具目录

这条命令会把新的目录追加到现有PATH的末尾，从而让系统也能在该目录中查找命令。需要注意的是，这种方式只在当前终端会话中生效，关闭终端后就会失效；如果希望永久生效，需要把这一行写入~/.bashrc或~/.zshrc等配置文件里。

>

/bin/ls

就能运行？

因为Linux会去PATH中指定的目录寻找ls。

查看：

echo $PATH

可能得到：

/usr/local/bin:/usr/bin:/bin:/usr/local/sbin

这些目录之间用：

:

分隔。

Linux执行：

ls

大致会：

ls ↓ 去PATH中的目录找 ↓ /usr/local/bin/ls ↓ 没找到 ↓ /usr/bin/ls ↓ 找到了 ↓ 执行

2.HOME

echo $HOME

例如普通用户可能得到：

/home/whb

root可能是：

/root

HOME表示：当前用户的主目录

3.SHELL环境变量

查看：

echo $SHELL

可能得到：

/bin/bash

表示：当前用户默认使用的Shell。

例如：

/bin/bash

就是 Bash。

测试：

假设你写了：

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

编译：

gcc hello.c -o hello

当前目录：

hello

---

方法一：./hello

执行：

./hello

这里：

.

表示：当前目录

所以：

./hello

就是执行当前目录下的hello程序。

因此可以运行。

---

方法二：直接输入hello

如果输入：

hello

Linux会去：

PATH

里面寻找hello。

例如：

/usr/local/bin /usr/bin /bin ...

但是你的hello在：

当前目录

而当前目录通常不在PATH中。

所以：

hello

找不到。

于是报：

command not found

3.和环境变量相关的命令

1.echo—— 查看某一个环境变量

语法：

echo $变量名

例如：

echo $PATH

输出：

/usr/local/bin:/usr/bin:/bin

表示查看PATH的值。

再比如：

echo $HOME

可能输出：

/home/whb

为什么前面有$？

$PATH

表示：把PATH这个变量里面保存的值取出来。

所以：

echo PATH

和：

echo $PATH

是不一样的。

---

2.export—— 设置/导出环境变量

例如：

export MYNAME=hello

然后：

echo $MYNAME

得到：

hello

这里相当于：

MYNAME = hello

并且通过export，它成为环境变量，子进程也可以继承。

例如：

export TEST=123 ./a.out

a.out这个程序就可以读取TEST。

要区分：

MYNAME=hello

和：

export MYNAME=hello

前者只是 Shell 本地变量。

后者是 环境变量，可以传给子进程。

可以简单记：export = 把 Shell 变量“导出”给子进程。

3.env—— 查看所有环境变量

直接输入：

env

会显示很多环境变量，例如：

PATH=/usr/local/bin:/usr/bin:/bin HOME=/home/whb SHELL=/bin/bash USER=whb PWD=/home/whb/test

所以：

echo $PATH

是只看 PATH

而：

env

是看所有环境变量

---

4.unset—— 删除环境变量

例如：

export MYNAME=hello

现在：

echo $MYNAME

得到：

hello

然后：

unset MYNAME

再：

echo $MYNAME

就没有值了。

所以：

unset 变量名

就是删除这个变量。

注意这里不加$：

unset MYNAME # 正确 unset $MYNAME # 不应该这样写

因为unset操作的是变量本身，不是变量的值。

---

5.set—— 查看 Shell 变量 + 环境变量

输入：

set

会显示当前 Shell 中定义的变量，内容通常很多。

可以简单理解成：

set ↓ Shell变量 + 环境变量

而：

env ↓ 主要查看环境变量

4. 环境变量的组织方式

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

环境表

假设系统有这些环境变量：

PATH=/usr/bin:/bin HOME=/home/whb SHELL=/bin/bash USER=whb

程序运行时，这些环境变量可以组织成：

环境表 | ↓ +---------------------+ | 指针1 ───────────────┼────→ "PATH=/usr/bin:/bin\0" +---------------------+ | 指针2 ───────────────┼────→ "HOME=/home/whb\0" +---------------------+ | 指针3 ───────────────┼────→ "SHELL=/bin/bash\0" +---------------------+ | 指针4 ───────────────┼────→ "USER=whb\0" +---------------------+ | NULL | +---------------------+

这就是：字符指针数组char *env[]

例如：

环境变量：

PATH=/usr/bin:/bin

实际上是一个完整字符串：

P A T H = / u s r / b i n : / b i n \0

意思就是：

env[0] ───→ PATH=/usr/bin:/bin\0 env[1] ───→ HOME=/home/whb\0 env[2] ───→ SHELL=/bin/bash\0

所以每个指针指向一个以'\0'结尾的环境字符串。

假设有：

char *env[] = { "AAA=111", "BBB=222", "CCC=333", NULL };

最后的：

NULL

作用是：告诉程序：环境变量已经结束了。

类似字符串使用：

'\0'

表示结束。

环境表使用

NULL

表示结束。

所以：

字符串： 字符 → 字符 → 字符 → '\0' ↑ 结束 环境表： env[0] → 字符串 env[1] → 字符串 env[2] → 字符串 env[3] → NULL ↑ 结束

---

可以这样遍历环境表

Linux程序中通常可以使用：

extern char **environ;

environ指向环境表。

例如：

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

运行后可能输出：

PATH=/usr/local/bin:/usr/bin:/bin HOME=/home/whb SHELL=/bin/bash USER=whb ...

5.通过系统调⽤获取或设置环境变量

getenv()

函数原型：

char *getenv(const char *name);

作用：根据环境变量的名字，找到它对应的值。

比如我们之前在命令行中：

echo $PATH

可以查看 PATH。

在 C 程序里面，就可以：

getenv("PATH")

获取 PATH 的值。

返回类型：

char *

也就是说：返回一个指向环境变量值字符串的字符指针。

例如：

char *p = getenv("PATH");

那么：

p ↓ "/usr/bin:/bin\0"

因此可以：

printf("%s\n", p);

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

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

例如：

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

直接运行：

./test

程序执行：

char *env = getenv("MYENV");

但是当前环境中没有：

MYENV=hello world

所以：

getenv("MYENV")

返回：

NULL

于是：

if(env)

相当于：

if(NULL)

条件不成立，所以：

printf("%s\n", env);

根本不会执行，因此没有输出。

执行export

export MYENV="hello world"

现在运行：

./test

./test是 Shell 启动的一个新进程。

关系可以简单画成：

Shell进程 │ │ 创建/启动 ↓ test进程

而 Shell 本身已经有：

MYENV=hello world

所以启动test时，Shell 会把自己的环境变量传递给新程序。

于是：

Shell环境： MYENV=hello world ↓ ↓ 继承 ↓ test进程环境： MYENV=hello world

所以test中：

getenv("MYENV")

就能找到：

hello world

于是输出：

hello world

子进程继承的是父进程的环境，但之后它们是相互独立的。

例如：

父进程： MYENV=hello ↓ 创建子进程 子进程： MYENV=hello

如果子进程把自己的环境改成：

MYENV=world

一般不会导致父进程变成：

MYENV=world

父进程仍然是：

MYENV=hello

可以理解为创建子进程时，子进程获得父进程环境的副本。

必须使用export

假设你只写：

MYENV="hello world"

然后：

./test

可能还是没有输出。

因为：

MYENV="hello world"

只是当前 Shell 的本地 Shell 变量，不一定会放进传给子进程的环境表。

而：

export MYENV="hello world"

相当于：

Shell变量 ↓ export ↓ 环境变量 ↓ 加入环境表 ↓ 子进程可以继承

这就是导出环境变量

二.程序地址空间

1.虚拟地址

示例1：

#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.h> int g_val = 0; int main() { pid_t id = fork(); if(id < 0) { perror("fork"); return 0; } else if(id == 0) { // child 子进程 printf("child[%d]: %d : %p\n", getpid(), g_val, &g_val); } else { // parent 父进程 printf("parent[%d]: %d : %p\n", getpid(), g_val, &g_val); } sleep(1); return 0; }

可能输出：

parent[2995]: 0 : 0x80497d8 child[2996]: 0 : 0x80497d8

因为fork()后，子进程会以父进程为模板，拥有相同的虚拟地址空间布局。

所以父子进程看到的：

g_val

对应的虚拟地址都是：

0x80497d8

示例2：

#include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.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; }

可能输出：

child[3046]: 100 : 0x80497e8 parent[3045]: 0 : 0x80497e8

问题来了：

如果：

0x80497e8

真的是物理地址，

那么父进程和子进程访问的应该是同一块物理内存。

子进程：

g_val = 100;

改了它。

那么父进程再读取：

g_val

应该也得到：

100

但实际却是：

父进程：0 子进程：100

所以：&g_val打印出来的地址不是物理地址。

这个地址叫：虚拟地址

包括我们平时写 C/C++：

int a = 10; printf("%p", &a);

看到的地址：

0x7ffffff...

是：虚拟地址

不是内存条上的真实物理地址。

真正的物理内存可以简单理解成：

物理内存 +----------------+ | 真实的内存空间 | | | | | +----------------+

但是普通用户程序不能直接随意操作物理地址。

Linux 操作系统负责管理物理内存。

程序看到的是：

程序 ↓ 虚拟地址 ↓ 操作系统 + 页表 ↓ 物理地址 ↓ 真正的物理内存

也就是：

虚拟地址 ──────→ 物理地址

OS必须负责将 虚拟地址转化成 物理地址

为什么fork()后一开始还可以共享？

这里就要引出一个非常重要的机制：写时拷贝（Copy-On-Write，COW）

fork()刚创建子进程的时候，操作系统并不会马上把父进程所有内存完整复制一份。

而是先让父子进程：

父进程虚拟地址 ─┐ ├──→ 同一块物理内存 子进程虚拟地址 ─┘

例如：

父进程 子进程 0x80497e8 0x80497e8 │ │ └────────┬─────────────┘ ↓ 物理内存 A g_val = 0

此时父子进程都没有修改：

父：0 子：0

所以完全没问题。

---

当子进程执行g_val = 100呢？

这时候事情发生变化。

子进程要：

g_val = 100;

操作系统发现：“这块内存目前和父进程共享，子进程现在要写它。”

于是触发：写时拷贝

操作系统给子进程准备一块新的物理内存：

修改之前： 父进程虚拟地址 ──┐ ├──→ 物理内存A 子进程虚拟地址 ──┘ g_val=0

修改之后：

父进程： 0x80497e8 │ ↓ 物理内存 A g_val = 0 子进程： 0x80497e8 │ ↓ 物理内存 B g_val = 100

注意：

虚拟地址没变！

仍然都是：

0x80497e8

但是：

映射到的物理地址变了！

父：

虚拟地址 → 物理地址A

子：

虚拟地址 → 物理地址B

这就是同一个变量，地址相同，其实是虚拟地址相同；内容不同，其实是被映射到了不同的物理地址。

2.为什么要设计虚拟地址？

如果没有虚拟地址，所有程序直接使用物理地址：

程序A ──→ 物理内存 程序B ──→ 物理内存 程序C ──→ 物理内存

那么不同程序之间很容易互相覆盖、破坏。

有了虚拟地址之后：

进程A虚拟地址空间 ↓ 页表A ↓ 物理内存 进程B虚拟地址空间 ↓ 页表B ↓ 物理内存

每个进程都有自己的进程地址空间。

这样可以实现：

• 进程之间相互隔离
• 提高内存管理效率
• 实现虚拟内存
• 实现写时拷贝
• 程序不需要知道真实物理地址

3.虚拟内存管理

描述linux下进程的地址空间的所有的信息的结构体是 个mm_struct结构，在每个进程的 mm_struct （内存描述符）。每个进程只有⼀ task_struct 结构中，有⼀个指向该进程的mm_struct结构体指针。

例如：

struct task_struct { /* ... */ struct mm_struct *mm; /* ... */ };

这里：

struct mm_struct *mm;

是一个指针。

它指向：

mm_struct

也就是这个进程对应的虚拟地址空间描述信息。

可以画成：

task_struct ┌────────────────────┐ │ PID │ │ 状态 │ │ 优先级 │ │ ... │ │ │ │ mm ────────────────┼────→ mm_struct └────────────────────┘ │ ↓ 虚拟地址空间

每⼀个进程都会有⾃⼰独⽴的 mm_struct ， 这样每⼀个进程都会有⾃⼰独⽴的地址空间才能互不⼲扰。

例如：

进程A 进程B mm_struct A mm_struct B ↓ ↓ 地址空间A 地址空间B ↓ ↓ 虚拟地址0x1000 虚拟地址0x1000 ↓ ↓ 物理内存A 物理内存B

虽然：

进程A：0x1000 进程B：0x1000

可能是一样的虚拟地址，但是可以通过不同的页表映射到不同的物理内存。

因此不同进程拥有独立的虚拟地址空间，从而实现进程之间的内存隔离。

4.mm_struct

struct mm_struct { struct vm_area_struct *mmap; struct rb_root mm_rb; unsigned long task_size; unsigned long start_code, end_code; unsigned long start_data, end_data; unsigned long start_brk, brk; unsigned long start_stack; unsigned long arg_start, arg_end; unsigned long env_start, env_end; /* ... */ };

mm_struct就像一张“进程虚拟地址空间的地图”。

它记录了：

代码在哪里？ 数据在哪里？ 堆在哪里？ 栈在哪里？ 参数在哪里？ 环境变量在哪里？ 有哪些虚拟内存区域？

例如：

unsigned long start_code, end_code;

表示代码段的开始和结束位置。

unsigned long start_data, end_data;

表示数据段的开始和结束位置。

unsigned long start_brk, brk;

和堆（heap）有关

---

unsigned long start_stack;

表示栈的起始位置。

unsigned long arg_start, arg_end;

表示：命令行参数区域。

比如：

./test hello 123

这里的：

hello 123

就是命令行参数。

unsigned long env_start, env_end;

表示：环境变量所在区域。

5.vm_area_struct

linux内核使⽤ vm_area_struct 结构来表⽰⼀个独⽴的虚拟内存区域(VMA)，由于每个不同质的虚 拟内存区域功能和内部机制都不同，因此⼀个进程使⽤多个vm_area_struct结构来分别表⽰不同类型 的虚拟内存区域。上⾯提到的两种组织⽅式使⽤的就是vm_area_struct结构来连接各个VMA，⽅便进 程快速访问

一个进程的虚拟地址空间不是一整块完全一样的区域。

例如：

┌───────────────────┐ │ 栈 │ ├───────────────────┤ │ │ │ ... │ ├───────────────────┤ │ 堆 │ ├───────────────────┤ │ 数据段 │ ├───────────────────┤ │ 代码段 │ └───────────────────┘

代码、数据、堆、栈的：

• 权限
• 用途
• 管理方式

都可能不同。

所以 Linux 使用：

struct vm_area_struct

来描述一个独立的虚拟内存区域。

简称：VMA（Virtual Memory Area）

---

一个进程有很多 VMA

比如一个进程：

进程A │ ↓ mm_struct │ ├── VMA 1 → 代码段 │ ├── VMA 2 → 数据段 │ ├── VMA 3 → 堆 │ ├── VMA 4 → 共享库 │ ├── VMA 5 → 栈 │ └── ...

所以：

mm_struct ↓ 管理整个地址空间 vm_area_struct ↓ 描述其中一个具体的虚拟内存区域

---

vm_area_struct里面最重要的两个成员

unsigned long vm_start; unsigned long vm_end;

分别表示：

vm_start → 虚拟内存区域开始地址 vm_end → 虚拟内存区域结束地址

比如：

VMA ┌──────────────────────┐ │ │ │ 某个区域 │ │ │ └──────────────────────┘ ↑ ↑ vm_start vm_end

所以一个 VMA 本质上就是：从虚拟地址 A 到虚拟地址 B 的这一段区域，它是什么、有什么权限、怎么管理。

---

vm_next和vm_prev

struct vm_area_struct *vm_next; struct vm_area_struct *vm_prev;

这两个就是：前后指针。

因此可以把多个 VMA 连接起来：

VMA1 ←→ VMA2 ←→ VMA3 ←→ VMA4

这就是双向链表。

而：

struct vm_area_struct *mmap;

可以指向这个链表。

所以当虚拟区间较少时，可以通过链表管理。

如果一个进程有很多 VMA：

VMA1 VMA2 VMA3 ... VMA100 VMA101 ...

如果每次寻找某个地址对应哪个 VMA，都从头开始链表查：

VMA1 → VMA2 → VMA3 → ...

效率可能比较低。

所以还可以使用：红黑树

struct rb_root mm_rb;

就是红黑树的根。

可以简单理解：

mm_struct / \ 链表 红黑树 ↓ ↓ vm_area_struct vm_area_struct

6.为什么一定需要虚拟地址空间？

如果程序直接操作物理内存，会怎么样？

假设电脑有：

128MB物理内存

程序A需要：

10MB

程序B需要：

110MB

可以分：

物理内存 0MB │ ├──────── A 10MB ────────┤ │ ├──────── B 110MB ──────────────────────┤ │ └────────────────────────────────────────┘ 128MB

看起来能运行。

但是这种方式问题非常大。

---

第一个问题：安全性

如果程序直接操作物理地址：

程序A ↓ 物理内存

那么理论上程序A可能去访问：

程序B的内存

甚至：

操作系统内核的内存

那就非常危险。

例如恶意程序：

修改其他程序数据 ↓ 修改系统数据 ↓ 系统崩溃

所以必须进行隔离。

有了虚拟地址：

进程A ↓ 虚拟地址空间A ↓ 页表A ↓ 物理内存

程序不能随意访问别人的虚拟地址空间。

---

第二个问题：地址不确定

假设程序里面有：

int a = 10;

如果直接使用物理地址。

第一次运行：

物理地址： 0x1000

第二次运行，由于内存已经被其他程序占用了：

物理地址： 0x5000

那么程序每次运行实际地址都可能不同。

这对程序非常麻烦。

---

有虚拟地址之后

程序只需要认为：

a → 0x1000

每次都可以使用这个虚拟地址。

操作系统再负责：

虚拟地址0x1000 ↓ 页表 ↓ 物理地址可能是0x5000

下一次：

虚拟地址0x1000 ↓ 页表 ↓ 物理地址可能是0x9000

程序完全不需要知道。

---

第三个问题：提高内存利用率

假设物理内存不够。

没有虚拟内存时：

整个进程 ↓ 一起搬到磁盘

这样效率很低。

有虚拟内存和分页机制以后，可以：

进程的一部分页面 ↓ 物理内存 暂时不用的页面 ↓ 磁盘

不需要把整个进程一次性搬走。

所以效率更高。

7.malloc 申请的是虚拟空间

在 C/C++ 中使用malloc、new申请空间时，本质上是向进程的地址空间申请。

例如：

int *p = malloc(100 * sizeof(int));

你可能以为：“操作系统马上给我一块真实物理内存。”

实际上不能简单这么理解。

可以理解成：

malloc ↓ 申请虚拟地址空间 ↓ 操作系统建立/准备相应的内存管理关系

真正访问页面时，如果页面尚未准备好，操作系统可能通过缺页异常等机制分配物理页并建立映射。

这就是延迟分配。

---

8.“进程管理”和“内存管理”解耦

以前如果程序直接使用物理地址：

程序 ↓ 直接占用物理内存

程序和物理内存的位置强相关。

有了虚拟地址以后：

进程 ↓ 虚拟地址空间 ↓ 页表 ↓ 物理内存

于是：进程只需要关心自己的虚拟地址空间，物理内存由操作系统统一管理。

这就是进程管理模块和内存管理模块解耦。

---

9.为什么程序看到的地址可以是“连续”的？

这是虚拟地址非常厉害的地方。

例如程序认为：

虚拟地址： 0x1000 0x2000 0x3000 0x4000

是连续的。

但实际物理内存可能：

虚拟地址 物理地址 0x1000 → 0x8000 0x2000 → 0x2000 0x3000 → 0xF000 0x4000 → 0x5000

物理内存可以是分散的。

但是从进程角度看：

0x1000 ↓ 0x2000 ↓ 0x3000 ↓ 0x4000

依然是连续、有序的。

所以在进程视角，所有的内存分布都可以是有序的。