---

1.冯诺依曼体系结构

输入设备：包括键盘，鼠标，话筒，摄像头，usb，磁盘等
中央处理器（CPU）：含运算器和控制器
输出设备：显示器等
存储器：内存

注意：
cpu能且只能对内存进行读写，不能访问外设
外设要输入或者输出数据，也只能写入内存或者从内存中读取

原因可以用木桶原理来解释，cpu的计算和读取速率是纳秒级别的，内存的读取速率是微妙到纳秒级别的，而输入输出单元读取速率是毫秒到微妙级别的，如果说cpu直接和输入输出单元打交道，二者速率相差甚远，也就会大量出现cpu等输入输出单元，会拉低cpu的效率，所以cpu在设置上不会直接和输入输出单元打交道

在程序运行之前，必须先加载到内存，程序=代码+数据，最终都要CPU来处理，CPU需要先读取到这些代码和数据，而CPU和内存有“数据（二进制层面）”层面的交互，也就是exe可执行程序，本质上还是一个文件，只能在磁盘中保存

2.操作系统（先描述，再组织）

操作系统是一款进行软硬件管理的软件，也就是第一个加载的程序
操作系统存在的意义是：为了将软硬件管理好，给用户提供良好（稳定，高效，安全）使用环境
操作系统包括：
内核（进程管理，内存管理，文件管理，驱动管理）
其他程序（函数库，shell外壳程序等等）

操作系统管理硬件：用struct结构体描述要管理的硬件，然后用双向链表其他更加适用的数据结构来组织

操作系统不会去相信任何人，但又要为人提供服务，所以操作系统会暴露自己的部分接口，供上层开发使用，也叫做系统调用
库就是系统调用的函数封装的结合体

3.进程

程序vs进程
程序是在磁盘上的exe可执行程序
而进程是可执行程序从磁盘上拷贝到内存中，操作系统为了管理进程会生成相应的PCB结构体来管理内存中的程序
所以进程=内存中运行的可执行程序+PCB结构体

所以操作系统管理进程其实是对PCB结构体形成各种数据结构进行管理
PCB在Liunx里是task_struct

task_struct
{
    //标示符: 描述本进程的唯一标示符，用来区别其他进程
    //状态: 任务状态，退出代码，退出信号等
    //优先级: 相对于其他进程的优先级。
    //程序计数器: 程序中即将被执行的下一条指令的地址
    //内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
    //上下文数据: 进程执行时处理器的寄存器中的数据
    //I／O状态信息: 包括显示的I/O请求,分配给进程的I／O设备和被进程使用的文件列表
    //其他信息
}

需要注意的是进程PCB不是只在一个数据结构里，而是同时存在多个数据结构里

struct task_struct
{
    struct task_struct* next;
    struct task_struct* prev;
    struct dlist list;//系统所有程序所在的列表
    struct dlist queue;//同时这个进程还可以在队列中
    //也可以在各种其他结构中！！！
}
struct dlist
{
    struct dlist* next;
    struct dlist* prev;
}

//这里是取task_struct里的各种字段的一种方式
#define curr(list) (struct task_struct*)((int)&list-(int)&(task_struct*)0->list)
curr(list)->pid;

3.1查看进程的方式

ls /proc/
top
ps

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

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

3.4查看进程中常见字段状态的指令

while :; do ps ajx | head -1 && ps ajx | grep mytest | grep -v grep;sleep 1;echo "-----------------------";done

3.3fork创建子进程

创建一个进程，就是系统中要申请内存，保存当前进程的可执行程序+task_struct对象，并将task_struct对象添加到进程列表中。

fork有两个返回值,给子进程返回0，给父进程返回子进程的pid
父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）
fork之后通常要用if进行分流

3.3.1fork的原理

fork创建子进程，系统中会多一个子进程，它会以父进程为模板，为子进程创建PCB，父子的代码是共享的，但数据是各自私有一份。

fork之后如果没有if-else分流的话，会执行一样的代码，fork之前的代码是只有父进程在执行，那为什么子进程不执行fork之前的代码呢，其原因是pc/eip执行fork完毕，eip指向fork后序的代码，eip在pcb内部保存，所以eip也会被子进程继承。

fork之后父子进程谁先运行这个问题，其实是不确定的因为创建完成之后，与系统的其他进程都要被调度执行，PCB都在运行队列中排队，这要看哪个进程的PCB先被选择调度，哪个进程就先运行，而运行的先后由各自PCB中调度信息（时间片，优先级等）+调度器算法共同决定。

进程的独立性，体现在各自有自己的PCB进行之间不会相互影响，而共享的代码本身是只读，无法修改，代码共享，数据各自私有一份。

fork有两个返回值的原因在于，fork就是一个函数，函数有返回值，fork之后代码共享，return也要被共享，父进程被调度要执行return，子进程也是如此，所以有两个返回值
但更准确的讲法，真实情况是操作系统通过一些寄存器做到返回值返回两次

3.4进程状态

R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里

S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））

D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束

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

X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

Z(zombie)-僵尸进程:是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用）没有读取到子进程退出的返回代码时就会产生僵死(尸)进程,僵死进程会以终止状态保持在进程表中，并且会一直在等待父进程读取退出状态代码。所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态
维护退出状态本身就是要用数据维护，也属于进程基本信息，所以保存在task_struct(PCB)中，换句话说，Z状态一直不退出，PCB一直都要维护,一直会占用内存，而没有去释放掉，久而久之内存占满，一连串的崩溃。

孤儿进程：父进程先退出，子进程就称之为“孤儿进程”，孤儿进程被1号init进程领养，之后会被init进程回收

3.5进程优先级

排队的本质：就是在确认优先级
基本概念：cpu资源分配的先后顺序，就是指进程的优先权（priority）
进程会有优先级的原因：本质是资源不足
进程的优先级其实是PCB中的PRI字段确认，数值越小，优先级越大

Linux进程的优先级数值范围：60~99
Linux中默认进程的优先级都是80
Linux是支持动态优先级调整的
Linux进程pcb中存在一个nice值：进程优先级的修正数据
pri（新）=pri（old）+nice
pri（old）都是从80开始的！
nice调整最小是：-20，超过部分统一当成-20
nice调整最大是：19，超过部分统一当成19
把优先级限定在一定的范围内其原因是：OS调度的时候，较为均衡的让每个进程都要得到调度，如果不控制在一定范围容易导致优先级较低的进程，长时间得不到CPU资源，也就是进程饥饿

修改nice值的方法

top
#进入后按r->输入进程PID->输入nice值

3.5.1Linux内核的调度队列与调度原理

运行队列会有两个字段，一个是活动队列另一个是过期队列
nr_active:总共有多少个运行状态的进程
queue[140]:一个元素就是一个进程队列，优先级相同的进程按照FIFO规则进行排队调度，数组下标就是优先级
bitmap[5]:一共140个优先级，一共140个进程队列，而bitmap有160个bit位，这里的比特位是用来判断队列是否为空，提高查找效率

本质上os当前运行的队列是活动队列，另一个队列就是过期队列，然而你所添加的进程会纳入过期队列中，等到当前活动队列的进程执行完，os就会调度到过期队列，也就是过期队列成了活动队列
值的注意的是Linux进程的优先级数值范围：60~99，也就是40个等级，其实总共有140个等级，前100个等级叫实时优先级，后40个叫普通优先级，我们能操作的时后40个，nice值也只与后四十个有关。

3.6环境变量

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

3.6.1常见的环境变量

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

3.6.2查看环境变量的方法

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

3.6.3和环境变量相关的命令

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

3.6.4环境变量的组织方式

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

3.6.5通过代码获取环境变量

1. 命令行第三个参数

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

2. 通过第三方变量environ获取

#include <stdio.h>
int main(int argc, char *argv[])
{
	extern char **environ;//environ是全局变量，里面存储的是
	int i = 0;
	for(; environ[i]; i++)
	{
		printf("%s\n", environ[i]);
	}
	return 0;
}

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

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

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

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

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

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

export MYENV="hello world"

再次运行程序，发现结果有了，说明：环境变量是可以被子进程继承下去

命令行启动的进程都是shell/bash的子进程，子进程的命令行参数和环境变量，是父进程bash给我们传递的。
我们直接更改的是bash进程内部的环境变量信息！
每一次重新登陆，都会给我们形成新的bush解释器并且新的bash解释器自动从读取形成自己的环境变量表信息！
环境变量信息是以脚本配置文件的形式存在的！
每一次登录的时候，bash进程都会读取 vim .bash_profile
配置文件的内容，为我们bash进程形成一张环境变量表信息！
本地变量只在bash进程内部有效，不会被子进程继承下去，环境变量是通过让所有的子进程继承的方式，实现自身的全局性

3.6.8Linux的命令分类

1. 常规命令，shell fork让子进程执行的
2. 内建命令，shell命令行的一个函数，当然可以直接读取shell内部定义的本地变量

4.进程地址空间

语言层面

系统层面

这里是fork后，子进程与父进程的代码共享，数据各自私有一份，子进程会拷贝父进程的task_struct,task_struct里的mm_struct所指向的进程地址空间也会拷贝一份，进程地址空间与物理地址所链接的页表也要拷贝一份，当子进程对其数据进行修改时，会进行写时拷贝，本拷贝下来父子进程代码和数据共享的，因为修改了数据，os会在内存中另开辟一块空间数据进行私有，让子进程页表中虚拟地址所对应的物理地址进行重新指向新的地址，但其虚拟地址并未进行修改，所以造成在语言层面，同一个地址出现两个不同值的情况。

关于页表不止只有虚拟地址和物理地址，还有访问权限字段，和是否分配&&是否有内容。
访问权限字段实现了代码段只能读不能写的功能
而内存是否分配和是否有内容体现在Linux的进程挂起状态

4.1地址空间与区域划分

地址空间也要被OS管理起来，每一个进程都要有地址空间，系统中一定要对地址空间做管理（先描述再组织），地址空间最终一定是一个内核的数据结构对象，就是一个内核结构体。

让进程以统一的视角看待内存，所以任意一个进程，可以通过地址空间+页表可以将乱序的内存数据，变成有序，分门别类的规划好。

存在虚拟地址空间，可以有效的进行进程访问内存的安全检查。

将进程管理和内存空间管理进行解耦

通过页表，让进程映射到不同的物理内存中，从而实现进程的独立性

父进程创建子进程的时候首先将自己的读写权限，改成只读，然后再创建子进程。
当父进程形成子进程之后，子进程写入，会发生写实拷贝（重新申请内存，进行拷贝，修改页表）,页表转换会因为权限问题出错

1. 真的出错了
2. 不是出错，触发我们进行重新申请内存

这里是操作系统介入