＜4＞_Linux进程概念
目录
一，冯诺依曼系统结构
1，计算机的硬件组件组成
2，对于冯诺依曼体系的理解
二，操作系统概念与定位
1，OS的概念
2，设计OS的目的
3，设计OS的定位
4，系统调用和库函数概念
三，深入理解进程概念，了解PCB
1，基本概念
2，描述进程-PCB
3，查看进程
4，通过系统调用创建进程-fork
四，学习进程状态，学会创建进程，掌握僵尸进程和孤儿进程，及其形成原因和危害
1，进程状态查看
2，僵尸进程
3，孤儿进程
五，了解进程调度，Linux进程优先级，理解进程竞争性与独立性，理解并行与并发
1，进程优先级
2，PRI and NI
3，PRI vs NI
4，进程性质
六，理解环境变量，熟悉常见环境变量及相关指令, getenv/setenv函数
1，什么是环境变量
2，常见的环境变量有哪些
3，环境变量常见的指令
4，环境变量的基本布局
5，如何获取环境变量
七，理解C内存空间分配规律，了解进程内存映像和应用程序区别, 认识地址空间
1，虚拟的地址空间
2，地址空间是如何设计的
3，为什么要有地址空间
点个赞吧！！haha
一，冯诺依曼系统结构
1，计算机的硬件组件组成
输入单元：包括键盘, 鼠标，扫描仪, 写板等
中央处理器(CPU)：含有运算器和控制器等
输出单元：显示器，打印机等
2，对于冯诺依曼体系的理解
这里的存储器指的是内存，不考虑缓存情况，这里的CPU能且只能对内存进行读写。不能访问外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。一句话，所有设备都只能直接和内存打交道。
对冯诺依曼的理解，不能停留在概念上，要深入到对软件数据流理解上
例如，从你登录上qq开始和某位朋友聊天开始，数据的流动过程。从你打开窗口，开始给他发消息，到他的到消息之后的数据流动过程。如果是在qq上发送文件呢？
输入设备（键盘输入数据）-- 内存（存储数据）-- CPU（计算数据并打包）-- 内存（把数据写回内存）-- 输出设备（刷新数据到网卡）-- 网络（传输数据）-- 输入设备（网卡接收数据）-- 内存（存储数据）-- CPU（解包数据计算内容）-- 内存（把数据写回内存）-- 输出设备（屏幕显示数据）
二，操作系统概念与定位
1，OS的概念
任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)
笼统的理解，操作系统包括：
内核（进程管理，内存管理，文件管理，驱动管理）
其他程序（例如函数库， shell程序等等）
2，设计OS的目的
与硬件交互，管理所有的软硬件资源
为用户程序（应用程序）提供一个良好的执行环境
3，设计OS的定位
在整个计算机软硬件架构中，操作系统的定位是： 一款纯正的“搞管理”的软件
计算机管理硬件：
1. 描述起来，用struct结构体
2. 组织起来，用链表或其他高效的数据结构
4，系统调用和库函数概念
在开发角度，操作系统对外会表现为一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分 由操作系统提供的接口，叫做系统调用。
系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统 调用进行适度封装，从而形成库，有了库，就很有利于更上层用户或者开发者进行二次开发。
三，深入理解进程概念，了解PCB
操作系统是怎么管理进行进程管理的呢？
很简单，先把进程描述起来，再把进程组织起来！
一个进程 = 代码和数据 + 内核为了管理该进程创建出来的结构体。
1，基本概念
课本概念：程序的一个执行实例，正在执行的程序等。
内核观点：担当分配系统资源（CPU时间，内存）的实体。
2，描述进程-PCB
什么叫做进程：进程=对应的代码和数据 + 进程对应的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链表的形式存在内核里。
3，查看进程
先创建一个进程。
//创建myproc.c文件和Make项目自动构建工具
[user@iZwz9eoohx59fs5a6ampomZ course]$ ll
total 20
-rw-rw-r-- 1 user user 74 Jun 23 20:11 Makefile
-rwxrwxr-x 1 user user 8536 Jun 23 20:12 myproc
-rw-rw-r-- 1 user user 195 Jun 23 20:09 myproc.c//Makefile文件
myproc:myproc.cgcc -o myproc myproc.c
.PHONY:clean
clean:rm -f myproc//myproc.c文件
#include <stdio.h>
#include <unistd.h>
int main()
{while(1){printf("hello world!\n"); sleep(1);}
}// 运行文件
[user@iZwz9eoohx59fs5a6ampomZ course]$ make
gcc -o myproc myproc.c
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
hello world!
hello world!
hello world!
hello world!
hello world!
...进程的信息可以通过 /proc 系统文件夹查看。
如：要获取PID为1的进程信息，你需要查看 /proc/1 这个文件夹。
[user@iZwz9eoohx59fs5a6ampomZ course]$ ls /proc
1 18205 26 387 568 consoles kmsg softirqs
10 19 27 39 626 cpuinfo kpagecount stat
100 2 275 421 647 crypto kpageflags swaps
1045 20 276 426 65 devices loadavg sys
11 21 28 47 6570 diskstats locks sysrq-trigger
12 22 29 49 6699 dma mdstat sysvipc
1215 2241 294 5 7 driver meminfo timer_list
1225 2244 295 50 776 execdomains misc timer_stats
13 2274 296 507 8 fb modules tty
13177 2275 3 51 839 filesystems mounts uptime
13185 23 342 52 845 fs mtrr version
13197 2308 36 528 9 interrupts net vmallocinfo
14 231 364 533 922 iomem pagetypeinfo vmstat
14529 24 37 537 924 ioports partitions zoneinfo
16 249 3714 546 acpi irq sched_debug
16153 25 3719 547 buddyinfo kallsyms schedstat
17358 250 3751 553 bus kcore scsi
18 254 3752 566 cgroups keys self
18185 257 38 567 cmdline key-users slabinfo[user@iZwz9eoohx59fs5a6ampomZ course]$ ps ajx | grep myproc2275 3714 3714 2244 pts/0 3714 S+ 1001 0:00 ./myproc3752 4349 4348 3719 pts/1 4348 S+ 1001 0:00 grep --color=auto mypro[user@iZwz9eoohx59fs5a6ampomZ course]$ ls /proc/3714
attr cwd map_files oom_adj schedstat task
autogroup environ maps oom_score sessionid timers
auxv exe mem oom_score_adj setgroups uid_map
cgroup fd mountinfo pagemap smaps wchan
clear_refs fdinfo mounts patch_state stack
cmdline gid_map mountstats personality stat
comm io net projid_map statm
coredump_filter limits ns root status
cpuset loginuid numa_maps sched syscall[user@iZwz9eoohx59fs5a6ampomZ course]$ ls /proc/3714 -al
total 0
dr-xr-xr-x 9 user user 0 Jun 23 20:15 .
dr-xr-xr-x 101 root root 0 Apr 22 15:25 ..
dr-xr-xr-x 2 user user 0 Jun 23 20:28 attr
-rw-r--r-- 1 user user 0 Jun 23 20:28 autogroup
-r-------- 1 user user 0 Jun 23 20:28 auxv
-r--r--r-- 1 user user 0 Jun 23 20:15 cgroup
--w------- 1 user user 0 Jun 23 20:28 clear_refs
-r--r--r-- 1 user user 0 Jun 23 20:16 cmdline
-rw-r--r-- 1 user user 0 Jun 23 20:16 comm
-rw-r--r-- 1 user user 0 Jun 23 20:28 coredump_filter
-r--r--r-- 1 user user 0 Jun 23 20:28 cpuset
lrwxrwxrwx 1 user user 0 Jun 23 20:28 cwd -> /home/user/qaq/course
-r-------- 1 user user 0 Jun 23 20:28 environ
lrwxrwxrwx 1 user user 0 Jun 23 20:16 exe -> /home/user/qaq/course/myproc
dr-x------ 2 user user 0 Jun 23 20:16 fd
dr-x------ 2 user user 0 Jun 23 20:28 fdinfo
-rw-r--r-- 1 user user 0 Jun 23 20:28 gid_map
-r-------- 1 user user 0 Jun 23 20:28 io
-r--r--r-- 1 user user 0 Jun 23 20:28 limits
-rw-r--r-- 1 user user 0 Jun 23 20:28 loginuid
dr-x------ 2 user user 0 Jun 23 20:28 map_files
-r--r--r-- 1 user user 0 Jun 23 20:28 maps
-rw------- 1 user user 0 Jun 23 20:28 mem
-r--r--r-- 1 user user 0 Jun 23 20:28 mountinfo
-r--r--r-- 1 user user 0 Jun 23 20:28 mounts
-r-------- 1 user user 0 Jun 23 20:28 mountstats
dr-xr-xr-x 5 user user 0 Jun 23 20:28 net
dr-x--x--x 2 user user 0 Jun 23 20:15 ns
-r--r--r-- 1 user user 0 Jun 23 20:28 numa_maps
-rw-r--r-- 1 user user 0 Jun 23 20:28 oom_adj
-r--r--r-- 1 user user 0 Jun 23 20:28 oom_score
-rw-r--r-- 1 user user 0 Jun 23 20:28 oom_score_adj
-r--r--r-- 1 user user 0 Jun 23 20:28 pagemap
-r-------- 1 user user 0 Jun 23 20:28 patch_state
-r--r--r-- 1 user user 0 Jun 23 20:28 personality
-rw-r--r-- 1 user user 0 Jun 23 20:28 projid_map
lrwxrwxrwx 1 user user 0 Jun 23 20:28 root -> /
-rw-r--r-- 1 user user 0 Jun 23 20:28 sched
-r--r--r-- 1 user user 0 Jun 23 20:28 schedstat
-r--r--r-- 1 user user 0 Jun 23 20:28 sessionid
-rw-r--r-- 1 user user 0 Jun 23 20:28 setgroups
-r--r--r-- 1 user user 0 Jun 23 20:28 smaps
-r--r--r-- 1 user user 0 Jun 23 20:28 stack
-r--r--r-- 1 user user 0 Jun 23 20:15 stat
-r--r--r-- 1 user user 0 Jun 23 20:19 statm
-r--r--r-- 1 user user 0 Jun 23 20:17 status
-r--r--r-- 1 user user 0 Jun 23 20:28 syscall
dr-xr-xr-x 3 user user 0 Jun 23 20:28 task
-r--r--r-- 1 user user 0 Jun 23 20:28 timers
-rw-r--r-- 1 user user 0 Jun 23 20:28 uid_map
-r--r--r-- 1 user user 0 Jun 23 20:28 wchan子进程和父进程
进程id（PID）
父进程id（PPID）
只要当前会话没切换，父进程不会变，重新启动该进程，则子进程会刷新。
[user@iZwz9eoohx59fs5a6ampomZ course]$ ps axj | head -1 && ps axj | grep myprocPPID PID PGID SID TTY TPGID STAT UID TIME COMMAND2275 9355 9355 2244 pts/0 9355 S+ 1001 0:00 ./myproc3752 9397 9396 3719 pts/1 9396 S+ 1001 0:00 grep --color=auto myproc
[user@iZwz9eoohx59fs5a6ampomZ course]$ ps axj | head -1 && ps axj | grep 'myproc'PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND2275 10142 10142 2244 pts/0 10142 S+ 1001 0:00 ./myproc3752 10148 10147 3719 pts/1 10147 S+ 1001 0:00 grep --color=auto myproc
[user@iZwz9eoohx59fs5a6ampomZ course]$ ps axj | head -1 && ps axj | grep 'myproc'PPID PID PGID SID TTY TPGID STAT UID TIME COMMAND2275 10154 10154 2244 pts/0 10154 S+ 1001 0:00 ./myproc3752 10159 10158 3719 pts/1 10158 S+ 1001 0:00 grep --color=auto myproc[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
hello world!, pid: 9355, ppid: 2275
hello world!, pid: 9355, ppid: 2275
hello world!, pid: 9355, ppid: 2275
^C
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
hello world!, pid: 10142, ppid: 2275
hello world!, pid: 10142, ppid: 2275
hello world!, pid: 10142, ppid: 2275
^C
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
hello world!, pid: 10154, ppid: 2275
hello world!, pid: 10154, ppid: 2275
hello world!, pid: 10154, ppid: 2275
^C4，通过系统调用创建进程-fork
fork有两个返回值：
失败时，返回-1
成功时，给父进程返回子进程的pid，给子进程返回0
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
I am parent proccess!
you can see me!!
you can see me!!
[user@iZwz9eoohx59fs5a6ampomZ course]$ cat myproc.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>int main()
{printf("I am parent proccess!\n");fork();printf("you can see me!!\n");return 0;
}[user@iZwz9eoohx59fs5a6ampomZ course]$ vim myproc.c
[user@iZwz9eoohx59fs5a6ampomZ course]$ make
gcc -o myproc myproc.c
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
I am parent proccess!
ret: 12638
ret: 0
[user@iZwz9eoohx59fs5a6ampomZ course]$ cat myproc.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>int main()
{printf("I am parent proccess!\n");pid_t ret = fork();printf("ret: %d\n", ret);
}[user@iZwz9eoohx59fs5a6ampomZ course]$ vim myproc.c
[user@iZwz9eoohx59fs5a6ampomZ course]$ make
gcc -o myproc myproc.c
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
I am parent proccess! pid: 13062
ret: 13063, pid: 13062, ppid: 3752
ret: 0, pid: 13063, ppid: 1
[user@iZwz9eoohx59fs5a6ampomZ course]$ cat myproc.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>int main()
{printf("I am parent proccess! pid: %d\n", getpid());pid_t ret = fork();// 变成两个进程，一个是父进程，一个是子进程printf("ret: %d, pid: %d, ppid: %d\n", ret, getpid(), getppid());
}四，学习进程状态，学会创建进程，掌握僵尸进程和孤儿进程，及其形成原因和危害
1，进程状态查看
父子进程被创建出来，不一定是谁先运行，这是由操作系统的调度器决定的。
进程状态：
运行态：只要task——struct结构体在运行队列中排队，就叫做运行态。
阻塞态：等待非CPU资源就绪，阻塞状态。
挂起态：当内存不足的时候，OS通过适当的置换进程的代码和数据到磁盘，进程的状态就叫做挂起。
为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在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 */
};R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
S睡眠状态（sleeping）：意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep）。
D磁盘休眠状态（Disk sleep）：有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。
T停止状态（stopped）：可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
Z僵尸状态（zombie）：进程退出时，一直等待父进程读取，资源没有释放和回收。
2，僵尸进程
进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。可父进程如果一直不读取，那子进程就一直处于Z状态？是的！
维护退出状态本身就是要用数据维护，也属于进程基本信息，所以需要保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护？是的！
那一个父进程创建了很多子进程，就是不回收，是不是就会造成内存资源的浪费？是的！因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间。
如何形成？
父进程创建出子进程，子进程退出了，不会立马释放所有资源，而是处于Z状态，需要父进程读取它的结果。如果父进程永远都不读取，就形成了僵尸进程，本质上就是资源没有释放完。
有什么危害？
僵尸进程不释放，就会造成内存资源的浪费，一直处于占用资源的状态。
3，孤儿进程
父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢？
父进程先退出，子进程就称之为“孤儿进程”。
孤儿进程被1号init进程领养，1号init就是系统本身，当然要有init进程回收喽。
如何形成？
父进程提前退出，之后子进程退出，没有父进程读取了，就会被其他进程领养，通常是1号init进程，也就是系统，不然僵尸状态一直保持，就没进程管理它
有什么危害？
和僵尸进程一样，就会造成内存资源的浪费，一直处于占用资源的状态。
五，了解进程调度，Linux进程优先级，理解进程竞争性与独立性，理解并行与并发
1，进程优先级
优先级 = 老的优先级（PRI） + nice值（NI）
[user@iZwz9eoohx59fs5a6ampomZ course]$ ps -al
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 20732 8468 0 80 0 - 1053 hrtime pts/3 00:00:00 myproc
0 R 1001 21182 12520 0 80 0 - 38309 - pts/1 00:00:00 psUID : 代表执行者的身份
PID : 代表这个进程的代号
PPID ：代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
PRI ：代表这个进程可被执行的优先级，其值越小越早被执行
NI ：代表这个进程的nice值
2，PRI and NI
PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小，进程的优先级别越高。
那NI呢? 就是我们所要说的nice值了，其表示进程可被执行的优先级的修正数值。
PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为： PRI(new)=PRI(old)+nice。
这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行。
所以，调整进程优先级，在Linux下，就是调整进程nice值，nice其取值范围是-20至19 ，一共40个级别。
3，PRI vs NI
需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
可以理解nice值是进程优先级的修正数据。
4，进程性质
竞争性: 系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的，为了高效完成任务，更合理竞争相关资源，便具有了优先级。
独立性: 多进程运行，需要独享各种资源，多进程运行期间互不干扰。
并行: 多个进程在多个CPU下分别，同时进行运行，这称之为并行。
并发: 多个进程在一个CPU下采用进程切换的方式，在一段时间之内快速切换进程，让多个进程都得以推进，称之为并发。
六，理解环境变量，熟悉常见环境变量及相关指令, getenv/setenv函数
1，什么是环境变量
环境变量(environment variables)一般是指在操作系统中，用来指定操作系统运行环境的一些参数。
如：我们在编写C/C++代码的时候，在链接的时候，从来不知道我们的所链接的动态静态库在哪里，但是照样可以链接成功，生成可执行程序，原因就是有相关环境变量帮助编译器进行查找。
环境变量通常具有某些特殊用途，还有在系统当中通常具有全局特性。
系统的命令可以直接运行，我自己写的程序必须带路径！如果不想带路径，想要像运行普通一样运行我们的程序，则需要配置环境变量。
2，常见的环境变量有哪些
PATH : 指定命令的搜索路径
HOME : 指定用户的主工作目录 (即用户登陆到Linux系统中时，默认的目录)
SHELL : 当前Shell，它的值通常是/bin/bash
查看环境变量：echo $NAME
[user@iZwz9eoohx59fs5a6ampomZ course]$ ll
total 20
-rw-rw-r-- 1 user user 74 Jun 25 15:07 Makefile
-rwxrwxr-x 1 user user 8640 Jun 26 15:04 myproc
-rw-rw-r-- 1 user user 187 Jun 26 15:04 myproc.c[user@iZwz9eoohx59fs5a6ampomZ course]$ echo $PATH
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/user/.local/bin:/home/user/bin[user@iZwz9eoohx59fs5a6ampomZ course]$ echo $HOME
/home/user[user@iZwz9eoohx59fs5a6ampomZ course]$ echo $SHELL
/bin/bash3，环境变量常见的指令
echo: 显示某个环境变量值
export: 设置一个新的环境变量
env: 显示所有环境变量
unset: 清除环境变量
set: 显示本地定义的shell变量和环境变量
4，环境变量的基本布局
每个程序都会收到一张环境表，环境表是一个字符指针数组，每个指针指向一个以‘\0’结尾的环境字符。
5，如何获取环境变量
通过第三方变量environ获取，或者getenv（）函数获取。
[user@iZwz9eoohx59fs5a6ampomZ course]$ env
XDG_SESSION_ID=11248
HOSTNAME=iZwz9eoohx59fs5a6ampomZ
TERM=xterm。。。。。。
LESSOPEN=||/usr/bin/lesspipe.sh %s
XDG_RUNTIME_DIR=/run/user/1001
_=./myproc[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
begin........................
/usr/local/bin:/usr/bin:/usr/local/sbin:/usr/sbin:/home/user/.local/bin:/home/user/bin
end..........................[user@iZwz9eoohx59fs5a6ampomZ course]$ cat myproc.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>int main(int argc, char *argv[], char *env[])
{printf("begin........................\n");printf("%s\n", getenv("PATH"));printf("end..........................\n");
}通过命令行第三个参数获取，传递给main（）函数的三个参数获取。
命令行参数最大的意义，可以让同样一个程序，通过选项的方式选择使用同一个程序的不同子功能。命令行参数是由父进程bash先拿到，再传递给子进程的。
[user@iZwz9eoohx59fs5a6ampomZ course]$ ll
total 24
-rw-rw-r-- 1 user user 187 Jun 27 15:31 1
-rw-rw-r-- 1 user user 74 Jun 25 15:07 Makefile
-rwxrwxr-x 1 user user 8584 Jun 27 16:46 myproc
-rw-rw-r-- 1 user user 428 Jun 27 16:46 myproc.c[user@iZwz9eoohx59fs5a6ampomZ course]$ cat myproc.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>int main(int argc, char *argv[], char *env[])
{if(argc != 2){printf("Usage: %s 至少要有一个选项\n", argv[0]);return 1;}if(strcmp("-a", argv[1]) == 0){printf("这个是功能一\n");}else if(strcmp("-b", argv[1]) == 0){printf("这个是功能二\n");}
}[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
Usage: ./myproc 至少要有一个选项
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc -a
这个是功能一
[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc -b
这个是功能二[user@iZwz9eoohx59fs5a6ampomZ course]$ cat myproc.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>int main(int argc, char *argv[], char *env[])
{printf("begin........................\n");int i;for(i = 0; env[i]; i++){printf("env[%d]:%s\n", i, env[i]);}printf("end..........................\n");
}[user@iZwz9eoohx59fs5a6ampomZ course]$ ./myproc
begin........................
env[0]:XDG_SESSION_ID=11248
env[1]:HOSTNAME=iZwz9eoohx59fs5a6ampomZ
env[2]:TERM=xterm。。。。。。
env[20]:LESSOPEN=||/usr/bin/lesspipe.sh %s
env[21]:XDG_RUNTIME_DIR=/run/user/1001
env[22]:_=./myproc
end..........................七，理解C内存空间分配规律，了解进程内存映像和应用程序区别, 认识地址空间
1，虚拟的地址空间
虚拟地址空间的示意图
写个小程序，对虚拟地址空间的排布，进行验证
[user@iZwz9eoohx59fs5a6ampomZ hello]$ cat hello.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>int g_unval;
int g_val = 100;int main(int argc, char *argv[], char *env[])
{printf("code addr: %p\n", main); //正文代码printf("init gloabl addr: %p\n", &g_val); //初始化数据printf("uninit global addr: %p\n", &g_unval); //未初始化数据char *heap_mem1 = (char*)malloc(10);char *heap_mem2 = (char*)malloc(10);char *heap_mem3 = (char*)malloc(10);char *heap_mem4 = (char*)malloc(10);printf("heap addr : %p\n", heap_mem1); //堆区printf("heap addr : %p\n", heap_mem2);printf("heap addr : %p\n", heap_mem3);printf("heap addr : %p\n", heap_mem4);printf("stack addr : %p\n", &heap_mem1); //栈区printf("stack addr : %p\n", &heap_mem2);printf("stack addr : %p\n", &heap_mem3);printf("stack addr : %p\n", &heap_mem4);int i;for(i = 0; i < argc; i++){printf("argv[%d]: %p\n", i, argv[i]); //命令行参数}int j;for(j = 0; env[j]; j++){printf("env[%d]: %p\n", j, env[j]); //环境变量}return 0;
}
[user@iZwz9eoohx59fs5a6ampomZ hello]$ ./hello
code addr: 0x40055d
init gloabl addr: 0x601034
uninit global addr: 0x60103c
heap addr : 0x25b7010
heap addr : 0x25b7030
heap addr : 0x25b7050
heap addr : 0x25b7070
stack addr : 0x7ffd699bd310
stack addr : 0x7ffd699bd308
stack addr : 0x7ffd699bd300
stack addr : 0x7ffd699bd2f8
argv[0]: 0x7ffd699bd7f4
env[0]: 0x7ffd699bd7fc
env[1]: 0x7ffd699bd811
env[2]: 0x7ffd699bd832
env[3]: 0x7ffd699bd83d
env[4]: 0x7ffd699bd84d
env[5]: 0x7ffd699bd85b
env[6]: 0x7ffd699bd87f
env[7]: 0x7ffd699bd895
env[8]: 0x7ffd699bd8a8
env[9]: 0x7ffd699bd8b2
env[10]: 0x7ffd699bd8f6
env[11]: 0x7ffd699bde92
env[12]: 0x7ffd699bdeac
env[13]: 0x7ffd699bdf08
env[14]: 0x7ffd699bdf21
env[15]: 0x7ffd699bdf32
env[16]: 0x7ffd699bdf49
env[17]: 0x7ffd699bdf51
env[18]: 0x7ffd699bdf61
env[19]: 0x7ffd699bdf6e
env[20]: 0x7ffd699bdfa4
env[21]: 0x7ffd699bdfc7
env[22]: 0x7ffd699bdfe62，地址空间是如何设计的
映射关系：虚拟地址空间-页表-物理内存空间
当我们的程序，在编译的时候，形成可执行程序的时候，没有被加载到内存中的时候，我们的程序内部有地址了吗？其实已经有地址了!
地址空间不要仅仅理解成为是OS内部要遵守的，其实编译器也要遵守。即编译器编译代码的时候，就已经给我们形成了各个区域的代码区和数据区。
并且采用和Linux内核中一样的编译方式，给每一个变量每一行代码都进行了编译，故程序在编译的时候，每一个字段早已经具有了一个虚拟地址。
程序内部的地址，依旧用的是编译器编译好的虚拟地址，当程序加载到内存的时候，每行代码和每个变量就有了一个物理地址。
当CPU读到指令的时候，指令内部也有地址，这个地址还是虚拟地址。CPU拿到虚拟地址之后，经过函数跳转到特定的位置，再通过页表映射，再进入物理内存，再拿到虚拟地址，CPU拿到的永远都是虚拟地址！
3，为什么要有地址空间
（1）保护物理内存的数据
因为由地址空间的存在，凡是非法访问的或者映射，OS都会识别，并终止这个进程！
这是不是有效的保护了物理内存嘛？
因为地址空间和列表是OS创建并维护的，是不是也就意味着，凡是想使用地址空间和页表进行映射，一定要在OS的监管之下来进行访问。
这便保护了物理内存中所有的合法数据，包括各个进程，以及内核相关的有效数据。
（2）提高新数据的加载速度
有页表的映射的存在，我们的内存中是不是可以对未来的数据进行任意位置的加载？
当然可以！！！
因为这样，物理内存的分配，就可以和进程的管理，做到没有关系。
内存管理模块 VS 内存管理模块，就完成了解耦合！
低耦合高内聚的模式，能更有效保护和管理程序。