操作系统学习

前言

1. 八股文：答到最关键的点就行了，不然怎么看都像是在死记硬背。
2. 参考：小林coding-图解系统

硬件结构

冯·诺依曼模型

1. 计算机基本结构：中央处理器（CPU）、内存、输入设备、输出设备、总线。
2. CPU：
   1. 32为和64为CPU最主要的区别在于一次能计算多少字节数据。
      1. 32为CPU可以计算64位的数字，但是不能一次计算。
      2. 32位CPU最大只能操作4GB的内存，而64位CPU寻址范围理论最大可以达到2^64。
      3. 线路位宽与CPU位宽：32位CPU位宽为32，一次最多只能操作32位宽的地址总线和数据总线（总线位宽太小又会影响效率）。
   2. CPU内部最常见组件：寄存器、控制单元和逻辑运算单元等。
      1. CPU中的寄存器主要作用是存储计算时的数据。为什么有了内存还要寄存器？因为内存离CPU太远了，而寄存器就在CPU中，还紧挨着控制单元和逻辑运算单元，使运算速度更快。
      2. 常见的寄存器种类：
         1. 通用寄存器：存放需要进行运算的数据，比如需要进行加运算的两个数据。
         2. 程序计数器：存储CPU要执行的下一条指令“所在的内存地址”。（指令还在内存中，只是存储了下一条指令的地址）
         3. 指令寄存器：存放程序计数器指向的指令，指令被执行完成之前，指令都存储在这里。
3. 总线：用于CPU和内存以及其他设备之间的通信，可分为3种：
   1. 地址总线
   2. 数据总线
   3. 控制总线：用于发送和接收信号。（一般不会用到，除非要发送信号）

程序执行的基本过程

1. 程序实际上是一条一条指令，所以程序的运行过程就是把每一条指令一步步的执行起来，负责执行指令的是CPU。
2. CPU执行程序的过程：
   1. 第一步，CPU读取程序计数器的值（即指令的内存地址），然后CPU的控制单元操作地址总线指定需要访问的内存地址，接着通知内存设备准备数据，数据准备好后通过数据总线将指令数据传给CPU，CPU收到内存传来的数据后，将这个指令数据存入到指令寄存器。
   2. 第二步，CPU分析指令寄存器中的指令，确定指令的类型和参数，如果是计算类型的指令，就把指令交给逻辑运算单元运算；如果是存储类型的指令，则交由控制单元指令（执行控制命令吗？）。
   3. 第三步，CPU执行完指令后，程序计数器的值自增，表示指向下一条指令。这个自增的大小，由CPU的位宽决定，比如32位的CPU，指令是4个字节，需要4个内存地址存放，因此程序计数器的值会自增4。
3. CPU的指令周期（也就是CPU时钟周期，CPU主频的倒数）：从程序计数器读取指令、到执行、再到下一条指令。
   1. CPU通过程序计数器读取对应内存地址的指令，这个部分称为Fecth（取得指令）；
   2. CPU对指令进行阶码，这个部分称为Decode（指令译码）；
   3. CPU将计算结果存回寄存器或者将寄存器的值存入内存，这个部分称为Store（数据回写）。

a=1+2执行具体过程

1. 汇编器编译成机器码之后，，，

存储器层次结构

1. 寄存器：速度最快，访问速度一般是半个时钟周期；内存最小（32位CPU中大多数寄存器可以存储4个字节）；价格也是最贵的。
2. CPU Cache：用的是SRAM（Static Random-Access Memory，静态随机存储器）的芯片。
   1. 静态：只要有电，数据就可以保持存在，而一旦断电，数据就会丢失。
3. 内存：用的是DRAM（Dynamic Random Access Memory，动态随机存取存储器）的芯片。
   1. 动态：电容，需要定时刷新。
   2. 相比于SRAM，DRAM的密度更高，功耗更低，有更大的容量，而且造假比SRAM芯片便宜很多。
4. SSD/HDD硬盘：
   1. SSD固态硬盘：断电后数据依然存在。
   2. HDD机械硬盘：访问速度最慢；如今和SSD价格差不多但是速度却慢很多，基本已经被淘汰了。
5. 每个存储器只和相邻的一层存储器设备打交道。
   1. 可以发现，不同的存储器之间性能差距很大，构造存储器分级很有意义，分级的目的是要构造缓存体系。

内存管理

虚拟内存

1. 地址：
   1. 虚拟内存地址（Virtual Memory Address）：我们程序所使用的内存地址；
   2. 物理内存地址（Physical Memory Address）：实际存在硬件里面的空间地址。
2. 操作系统是如何管理虚拟地址与物理地址之间的关系？
   1. 主要：内存分段、内存分页。

内存分段

1. 程序是由若干个逻辑分段组成的，如可由代码分段、数据分段、堆段、栈段组成。
   1. 不同的段是有不同的属性的，所以就用分段（Segmentation）的形式把这些段分离出来。
2. 分段——虚拟地址：段选择子+段内偏移量
   1. 段选择子：保存在段寄存器里面。段选择子里面最重要的是段号（初次之外还包含特权等标志位），用作段表的索引。段表里面保存的是这个段的基地址、段的界限和特权等级等。
   2. 段内偏移量：应该位于0和段界限之间，如果合法：物理内存地址=段基地址+段内偏移量。
3. 分段的优点：能产生连续的内存空间。
4. 分段的不足：
   1. 内存碎片；
      1. 外部内存碎片：产生了多个不连续的小物理内存，导致新的程序无法被装载；
      2. 内部内存碎片：程序所有的内存都被装载到了物理内存，但是这个程序有部分的内存可能并不是很常使用，这也会导致内存的浪费。
   2. 内存交换效率低。（内存交换：用于解决外部内存碎片）
      1. 内存交换的时候会先将占用的内存写到硬盘上，然后再从硬盘上读回到内存里。都会的之后紧紧跟着已经被占用的内存后面。
      2. 在Linux系统里，有一个Swap空间，这块空间是从硬盘划分出来的，用于内存和硬盘的空间交换。
      3. 因为如果经常写大文件，硬盘的访问速度比内存慢多了，所以内存交换效率低。
5. 为了解决内存分段的内存碎片和内存交换效率低的问题，就出现了内存分页。

内存分页

1. 用于解决内存分段的内存碎片和内存交换效率低的问题。
2. 分页：把整个虚拟和物理内存空间切成一段段固定尺寸的大小。这样一个连续并且尺寸固定的内存空间，我们叫页（Page）。在Linux下，每一页的大小为4KB。
3. 页表：存储在内存里，内存管理单元（MMU） 就做将虚拟内存地址转换成物理地址的工作。
   1. 缺页异常：当进程访问的虚拟地址在页表中查不到时，系统会产生一个缺页异常，进入系统内核空间分配物理内存、更新进程页表，最后返回用户空间，恢复进程的运行。
4. 分页是怎么解决分段的内存碎片、内存交换效率低的问题？
   1. 采用了分页，那么释放的内存都是以页为单位释放的 ，也就不会产生无法给进程使用的小内存。
   2. 如果内存空间不够，操作系统会把其他正在运的进程中的最近没被使的内存给释放掉，也就是暂时写在硬盘上，称为换出（Swap Out）。旦需要的时候，再加载进来，称为换（Swap In）。所以，次性写磁盘的也只有少数的个或者，不会花太多时间，内存交换的效率就相对较。
5. 内存转换地址，三个步骤：
   1. 把虚拟内存地址，切分成页号和偏移量；
   2. 根据页号，从页表里面，查询对应的物理页号；
   3. 直接拿物理页号，加上前面的偏移量，就得到了物理内存地址。

段页式内存管理

Linux内存管理

疑问

一些tips

1. 程序执行前需要先放到内存中才能被CPU处理，因此内存的主要作用就是缓和CPU与硬盘之间的速度矛盾。
2. 在多道程序环境下，系统中会有程序并发执行，也就是说会有多个程序的数据需要同时放到内存中。那么，如何区分各个程序的数据是放在什么地方的呢？
   1. 方案：给内存的存储单元编地址。
3. 程序运行过程如下：
   

进程与线程

进程、线程基础知识（就差信号量、Socket的完全理解了）

进程

1. 进程在活动期间有三种基本状态，即运行状态、就绪状态、阻塞状态。

线程

调度

进程间通信

管道

1. 分为匿名管道和命名管道。
   1. 命名管道，是一种先进先出的传输方式，所以也被称为FIFO
2. 管道传输数据是单向的，也就是半双工通信方式。
3. 管道这种通信方式效率低，不适合进程间频繁地交换数据。好处就是简单
4. 对于匿名管道，它的通信范围是存在父子关系的进程；对于命名管道，它可以在不相关的进程间也能相互通信。

消息队列

1. 消息队列是保存在内核中的消息链表。
2. 消息队列的不足：
   1. 不适合比较大数据的传输
   2. 消息队列通信过程中，存在用户态与内核态之间的数据拷贝开销。

共享内存

1. 共享内存的基址，就是拿出一块虚拟地址空间来，映射到相同的物理内存中

信号量

信号

Socket

多线程同步

1. 线程之间是可以共享资源的，比如代码段、堆空间、数据段、打开的文件等资源，但每个线程都有自己独立的栈空间（还有一些独立的寄存器）。

竞争与协作

互斥的概念

1. 互斥（mutualexclusion）：保证一个线程再临界区执行时，其他线程应该被阻止进入临界区。
   1. 临界区（critical section）：多线程执行操作共享变量的这段代码可能会导致竞争状态，因此我们将这段代码称为临界区。（简单来说就是，访问共享资源的代码片段）

同步的概念

2. 同步：并发进程/线程在一些关键点上可能需要互相等待与互通消息，这种相互制约的等待与互通信息称为进程/线程同步。

互斥与同步的实现和使用

1. 锁：加锁、解锁操作
2. 信号量：P、V操作
3. 锁和信号量都可以方便的实现进程/线程互斥，但是信号量比锁的功能更强一些，它还可以方便的实现进程/线程同步。
4. 互斥和同步的差别：
   1. 互斥：指散布在不同任务之间的若干程序片段，当某个任务运行其中一个程序片段时，其它任务就不能运行它们之中的任一程序片段，只能等到该任务运行完这个程序片段之后才可以运行。
   2. 同步：指散布在不同任务之间的若干程序片段，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。

锁

1. 根据锁的实现不同，可以分为忙等待锁和无忙等待锁。
   1. 忙等待锁：当获取不到锁时，线程就会一直等待不做任何事情，直到锁可用。
   2. 无忙等待锁：获取不到锁时，就会把当前线程放入到锁的等待队列，然后执行调度程序，把CPU让给其他线程执行，不用自旋。
2. 原子操作：要么全都执行，要么都不执行，不能出现执行到一半的中间状态。（同步是面向流程的）

信号量

1. 为共享资源提供了一个整数信号量s，同时提供两个原子操作P和V（为系统调用函数，用来控制信号量）。
   1. P操作：将s减1，相减后，如果s<0，则进程/线程进入阻塞等待，否则继续，表名P操作可能会阻塞。
   2. V操作：将s加1，相加后，如果s<=0，唤醒一个等待中的进程/线程，表明V操作不会阻塞。
   3. P操作是用在进入临界区之前，V操作是用在离开临界区之后，这两个操作必须成对出现。
   4. 先执行P、V操作，再判断是否可执行线程的xx操作。
2. 操作系统实现PV操作：
   1. 信号量实现临界区的互斥：初始时s=1，比如两个进程，任何想进入临界区的线程必先执行P，完成对临界资源的访问后再执行V操作。
      1. 第一个线程想进入临界区，因为初始时s=1，执行P操作之后s=0，表示临界资源为空闲，可分配给该进程，使之进入临界区。
      2. 若此时又有第二个线程想进入临界区，也应先执行P操作，结果使s变为负值，意味着临界资源已被占用，因此第二个线程被阻塞。
      3. 并且，直到第一个线程执行V操作，释放临界资源而恢复s值为0后，才唤醒第二个线程，使之进入临界区，待它完成临界资源的访问后，又执行V操作，使s恢复到初始值1。
      4. 对于两个并发线程，互斥量的值仅取1、0、-1三个值，分别表示：
         1. 如果互斥信号量为1，表示没有线程进入临界区
         2. 如果互斥信号量为0，表示有一个线程进入临界区
         3. 如果互斥信号量为-1，表示一个线程进入临界区，另一个线程等待进入
   2. 信号量实现时间同步：初始时s=0
      1. 具体的后面再说，不一定用到
         
         

生产者-消费者问题

1. 描述：
   1. 生产者在生成数据后，放在一个缓冲区中；
   2. 消费者从缓冲区取出数据处理；
   3. 任何时刻，只能有一个生产者或消费者可以访问缓冲区。
2. 问题分析：
   1. 任何时刻只能有一个线程操作缓冲区，说明操作缓冲区是临界代码，需要互斥；
   2. 缓冲区空时，消费者必须等待生产者生产数据；缓冲区满时，生产者必须等待消费者取出数据。说明生产者和消费者需要同步。
3. 问题解决：
   1. 我们需要三个信号量，分别是：
      1. 互斥信号量mutex：用于互斥访问缓冲区，初始化值为0
      2. 资源信号量fullBuffers：用于消费者询问缓冲区是否有数据，有数据则读取数据，初始化值为0（表明缓冲区一开始为空）
      3. 资源信号量emptyBuffers：用于生产者询问缓冲区是否有空位，有空位则生成数据，初始化值为n（缓冲区大小）
   2. 如果消费者线程一开始执行P(fullBuffers)，由于信号量fullBuffers初始值为0，则此时fullBuffers的值从0变为-1，说明缓冲区里没有数据，消费者只能等待。
   3. 接着，轮到生产者执行P(emptyBuffers)，表示减少一个空槽，如果当前没有其他生产者线程在临界区执行代码，那么该生产者线程就可以把数据放到缓冲区，放完后，执行V(fullBuffers)没信号了fulBuffers从-1变成0，表明有消费者线程正在阻塞等待数据，于是阻塞等待的消费者线程会被唤醒。
   4. 消费者线程被唤醒后，如果此时没有其他消费者线程在读数据，那么就可以直接进入临界区，从缓冲区读取数据。最后，离开临界区后，把空槽的个数+1。

经典同步问题

哲学家就餐问题

1. 方案一：每个哲学家同时拿了左边的叉子，也会导致死锁的现象。
2. 方案二：每次只能一个哲学家进餐，实现了互斥，但是每次进餐只能有以为哲学家而桌面上有5把叉子，显然不是最好的解决方案
3. 方案三：偶数先拿左边的叉子后拿右边的叉子，奇数编号的哲学家先拿右边的叉子后拿左边的叉子。即不会出现死锁也可以两个人同时进餐。
4. 方案四：一个哲学家只有在两个邻居都没有进餐时，才可以进入就餐状态。和方案三一样不会出现死锁，也可以两人同时进餐。

读者-写者问题

1. 方案一：读者优先
2. 方案二：写者优先
3. 方案三：公平策略：
   1. 优先级相同
   2. 写者、读者互斥访问
   3. 只能一个写者访问临界区
   4. 可以有多个读者同时访问临界资源

死锁

死锁的概念

1. 死锁：多个线程都在等待对方解放锁，在没有外力的作用下，这些线程会一直等待，就没办法继续运行。
   1. 简单来说，死锁问题的产生是由两个或者以上线程并行执行的时候，争夺资源而互相等待造成的。
2. 死锁只有同时满足以下四个条件才会发生：
   1. 互斥条件：多个线程不能同时使用同一个资源。
   2. 持有并等待条件：线程在等待资源2的同时不会释放自己已经持有的资源1。
   3. 不可剥夺条件：在自己使用完之前不能被其他线程获取。
   4. 环路等待条件：两个线程获取资源的顺序构成了环形链。

模拟死锁问题的产生

1. 之前学java的时候写过，实现两个线程都在等待对方释放资源即可。

利用工具排查死锁问题

1. jdk自带的线程堆栈分析工具：jstack。可以排查Java程序是否死锁

避免死锁问题的发生

1. 死锁只有同时满足互斥、持有并等待、不可剥夺、环路等待这四个条件的时候才会发生。所以要避免死锁问题，破外其中一个条件即可，最常用的方法是使用资源有序分配法来破外环路等待条件。

悲观锁与乐观锁

1. 常见的几种锁：互斥锁、自旋锁、读写锁、悲观锁、乐观锁。
2. 加锁的目的：保证共享资源在任意时间里，只有一个线程访问，这样就可以避免多线程竞争资源导致共享数据错乱的问题。

互斥锁与自旋锁：谁更轻松自如？

1. 最底层的两种锁，很多高低的锁都是基于它们实现的：互斥锁和自旋锁
2. 当已经有一个线程加锁后，其他线程加锁就会失败。
   1. 互斥锁加锁失败后，线程会释放CPU给其他线程；
      1. 释放CPU，线程加锁的代码就会被阻塞。对于互斥锁加锁失败而阻塞的现象，是由操作系统内核实现的。
      2. 当加锁失败，内核会将线程设置为睡眠状态，等到锁被释放后，内核会在合适的时机唤醒线程，当这个线程成功获取到锁后，就可以继续执行了。
   2. 自旋锁加锁失败后，线程会忙等待，直到它拿到锁。
      1. 忙等待：不释放CPU资源，一直等待加锁的线程执行完毕，然后立即为该线程加锁。
   3. 总结：当加锁失败时，互斥锁用线程切换来应对，自旋锁用忙等待来应对。
3. 互斥锁加锁失败后，会从用户态陷入内核态，让内核切换线程，虽然简化了使用锁的难度，但是存在一定的性能开销成本，即两次线程上下文切换的成本：
   1. 当线程加锁失败时，内核会把线程的状态从运行状态设置为睡眠状态，然后把CPU切换给其他线程运行；
   2. 接着，当线程释放时，之前睡眠状态的线程会变为就绪状态，然后内核会在合适的时间，把CPU切换给该线程运行。
4. 如果你能确定你锁住的代码执行时间很短，就不应该用互斥锁，而应该选用自旋锁，否则使用互斥锁。
5. 自旋锁加锁失败后，通过CPU提供的CAS（Compare And Swap），在用户态完成加锁和解锁操作，不会主动产生线程上下文切换，所以相比于互斥锁来说，开销会小一些，会快一些（相对于所著的代码执行时间很短而言）。
   1. 一般加锁的过程，包含两个步骤：
      1. 第一步，查看锁的状态，如果锁是空闲的，则执行第二步；
      2. 第二步，将锁设置为当前线程持有。
   2. CAS函数把这两个步骤合并成了一条硬件指令，形成原子指令。
      1. 原子指令：要么一次执行完两个步骤，要么两个不走都不执行。
6. 需要注意，在单核CPU中，需要抢占式的调度器（即不断通过时钟终端一个线程，运行其他线程）。否则，自旋锁在单CPU上无法使用，因为一个自旋的线程永远不会放弃CPU。

读写锁：读和写还有优先级区分？

1. 读写锁：由读锁和写锁两部分组成。
2. 应用：读写锁适用于能明确区分读操作和写操作的场景。
3. 读写锁的工作原理：
   1. 当写锁没有被线程持有时，多个线程能够并发的持有读锁，这大大提高了共享资源的访问效率，因为读锁是用于读取共享资源的场景，所以多个线程同时持有读锁也不会破坏共享资源的数据。
   2. 但是，一旦写锁被线程持有后，读线程的获取读锁的操作会被阻塞，而且其他写线程的获取写锁的操作也会被阻塞。
4. 写锁是独占锁，读锁是共享锁。
5. 读优先锁、写优先锁。
   1. 都有可能造成对方饿死。所以我们使用公平读写锁：用队列把获取锁的线程排队，不管是写线程还是读线程都按照先进先出的原则加锁即可，这样读线程仍然可以并发，也不会出现饥饿的现象。
6. 互斥锁和自旋锁都是最基本的锁，读写锁可以根据场景来选择这两种锁其中的一个进行实现。

乐观锁和悲观锁：做事的心态有何不同？

1. 前面提到的互斥锁、自旋锁、读写锁都是悲观锁。
2. 悲观锁：比较悲观，认为多线程同时修改共享资源的概论比较高，于是很容易出现冲突，所以访问共享资源前，要先上锁。
3. 乐观锁：做事比较乐观，它假定冲突的概论很低，它的工作方式是：先修改完共享资源，再验证这段时间内有没有发生冲突，如果没有其他线程再修改资源，那么操作完成，如果发现有其他线程已经修改过这个资源，就放弃本次操作。
   1. 乐观锁并没有加锁，所以也叫它无锁编程。
4. 注意：虽然乐观锁去除了加锁解锁的操作，但是一旦冲突发生，重试的成本非常高，所以只有再冲突概率非常低，且加锁成本非常高的场景时，才考虑使用乐观锁。

总结

八股文