- [前言](#前言)
- [一、概述](#一概述)
- [1. 操作系统基本特征](#1-操作系统基本特征)
- [1. 并发](#1-并发)
- [2. 共享](#2-共享)
- [3. 虚拟](#3-虚拟)
- [4. 异步](#4-异步)
- [2. 操作系统基本功能](#2-操作系统基本功能)
- [1. 进程管理](#1-进程管理)
- [2. 内存管理](#2-内存管理)
- [3. 文件管理](#3-文件管理)
- [4. 设备管理](#4-设备管理)
- [3. 系统调用](#3-系统调用)
- [4. 大内核和微内核](#4-大内核和微内核)
- [1. 大内核](#1-大内核)
- [2. 微内核](#2-微内核)
- [5. 中断分类](#5-中断分类)
- [1. 外中断](#1-外中断)
- [2. 异常](#2-异常)
- [3. 陷入](#3-陷入)
- [6. 什么是堆和栈？说一下堆栈都存储哪些数据？](#6-什么是堆和栈说一下堆栈都存储哪些数据)
- [7. 如何理解分布式锁？](#7-如何理解分布式锁)
- [二、进程管理](#二进程管理)
- [1. 进程与线程](#1-进程与线程)
- [1. 进程](#1-进程)
- [2. 线程](#2-线程)
- [3. 区别](#3-区别)
- [2. 进程状态的切换（生命周期）](#2-进程状态的切换生命周期)
- [3. 进程调度算法](#3-进程调度算法)
- [1. 批处理系统](#1-批处理系统)
- [1.1 先来先服务](#11-先来先服务)
- [1.2 短作业优先](#12-短作业优先)
- [1.3 最短剩余时间优先](#13-最短剩余时间优先)
- [2. 交互式系统](#2-交互式系统)
- [2.1 时间片轮转](#21-时间片轮转)
- [2.2 优先级调度](#22-优先级调度)
- [2.3 多级反馈队列](#23-多级反馈队列)
- [3. 实时系统](#3-实时系统)
- [4. 进程同步](#4-进程同步)
- [1. 临界区](#1-临界区)
- [2. 同步与互斥](#2-同步与互斥)
- [3. 信号量](#3-信号量)
- [使用信号量实现生产者-消费者问题](#使用信号量实现生产者-消费者问题)
- [4. 管程](#4-管程)
- [使用管程实现生产者-消费者问题](#使用管程实现生产者-消费者问题)
- [5. 经典同步问题](#5-经典同步问题)
- [1. 读者-写者问题](#1-读者-写者问题)
- [2. 哲学家进餐问题](#2-哲学家进餐问题)
- [6. 进程通信](#6-进程通信)
- [* 进程通信方式](#-进程通信方式)
- [直接通信](#直接通信)
- [间接通信](#间接通信)
- [1. 管道](#1-管道)
- [2. 命名管道](#2-命名管道)
- [3. 消息队列](#3-消息队列)
- [4. 信号量](#4-信号量)
- [5. 共享内存](#5-共享内存)
- [6. 套接字](#6-套接字)
- [7. 线程间通信和进程间通信](#7-线程间通信和进程间通信)
- [线程间通信](#线程间通信)
- [进程间通信](#进程间通信)
- [8. 进程操作](#8-进程操作)
- [创建一个进程](#创建一个进程)
- [父子进程的共享资源](#父子进程的共享资源)
- [fork()函数的出错情况](#fork函数的出错情况)
- [创建共享空间的子进程](#创建共享空间的子进程)
- [在函数内部调用vfork](#在函数内部调用vfork)
- [退出进程](#退出进程)
- [exit函数与内核函数的关系](#exit函数与内核函数的关系)
- [设置进程所有者](#设置进程所有者)
- [9. 孤儿进程和僵尸进程](#9-孤儿进程和僵尸进程)
- [基本概念](#基本概念)
- [问题及危害](#问题及危害)
- [测试代码](#测试代码)
- [僵尸进程解决办法](#僵尸进程解决办法)
- [10. 守护进程](#10-守护进程)
- [11. 上下文切换](#11-上下文切换)
- [三、死锁](#三死锁)
- [1. 什么是死锁](#1-什么是死锁)
- [2. 死锁的必要条件](#2-死锁的必要条件)
- [3. 死锁的处理方法](#3-死锁的处理方法)
- [1. 处理死锁的策略](#1-处理死锁的策略)
- [2. 死锁检测与死锁恢复](#2-死锁检测与死锁恢复)
- [3. 死锁预防](#3-死锁预防)
- [4. 死锁避免](#4-死锁避免)
- [4. 如何在写程序的时候就避免死锁](#4-如何在写程序的时候就避免死锁)
- [四、内存管理](#四内存管理)
- [1. 虚拟内存](#1-虚拟内存)
- [2. 分页系统地址映射](#2-分页系统地址映射)
- [3. 页面置换算法](#3-页面置换算法)
- [1. 最佳](#1-最佳)
- [2. 最近最久未使用](#2-最近最久未使用)
- [3. 最近未使用](#3-最近未使用)
- [4. 先进先出](#4-先进先出)
- [5. 第二次机会算法](#5-第二次机会算法)
- [6. 时钟](#6-时钟)
- [4. 分段](#4-分段)
- [5. 段页式](#5-段页式)
- [6. 分页与分段的比较](#6-分页与分段的比较)
- [五、设备管理](#五设备管理)
- [1. 磁盘结构](#1-磁盘结构)
- [2. 磁盘调度算法](#2-磁盘调度算法)
- [1. 先来先服务](#1-先来先服务)
- [2. 最短寻道时间优先](#2-最短寻道时间优先)
- [3. 电梯算法](#3-电梯算法)
- [六、链接](#六链接)
- [1. 编译系统](#1-编译系统)
- [1. 预处理阶段 (Preprocessing phase)](#1-预处理阶段-preprocessing-phase)
- [2. 编译阶段 (Compilation phase)](#2-编译阶段-compilation-phase)
- [3. 汇编阶段 (Assembly phase)](#3-汇编阶段-assembly-phase)
- [4. 链接阶段 (Linking phase)](#4-链接阶段-linking-phase)
- [2. 静态链接](#2-静态链接)
- [3. 目标文件](#3-目标文件)
- [4. 动态链接](#4-动态链接)
- [参考资料](#参考资料)
- [更新说明](#更新说明)
# 前言
在本文将深入展开在面试过程中操作系统部分的知识，用最简短的篇章深入理解。
参考资料：
- 《Linux+C程序设计大全》第四版，清华大学出版社，配套源码：[linux_c_program_design](https://github.com/frank-lam/linux_c_program_design)
- 《后台开发：核心技术与应用实践》
- 《操作系统》清华大学(向勇、陈渝) ，在线课程
- 部分信息来自：[CyC2018/CS-Notes](https://github.com/CyC2018/CS-Notes/blob/master/notes/%E8%AE%A1%E7%AE%97%E6%9C%BA%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F.md)
# 一、概述
## 1. 操作系统基本特征
### 1. 并发
并发是指宏观上在一段时间内能同时运行多个程序，而并行则指同一时刻能运行多个指令。
并行需要硬件支持，如多流水线或者多处理器。
操作系统通过引入进程和线程，使得程序能够并发运行。
## 5. 中断分类
### 1. 外中断
由 CPU 执行指令以外的事件引起，如 I/O 完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断等。
### 2. 异常
由 CPU 执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。
### 3. 陷入
在用户程序中使用系统调用。
| 类型 | 源头 | 响应方式 | 处理机制 |
| -------- | ------------------------ | ---------- | ------------------------------------ |
| 中断 | 外设 | 异步 | 持续，对用户应用程序是透明的 |
| 异常 | 应用程序意想不到的行为 | 同步 | 杀死或重新执行意想不到的应用程序指令 |
| 系统调用 | 应用程序请求操作提供服务 | 异步或同步 | 等待和持续 |
## 6. 什么是堆和栈？说一下堆栈都存储哪些数据？
栈区（stack）— 由**编译器**自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
堆区（heap） — 一般由**程序员分配释放**， 若程序员不释放，程序结束时可能由OS回收 。
数据结构中这两个完全就不放一块来讲，数据结构中栈和队列才是好基友，我想新手也很容易区分。
我想需要区分的情况肯定不是在数据结构话题下，而大多是在 OS 关于不同对象的内存分配这块上。
简单讲的话，在 C 语言中：
```c
int a[N]; // go on a stack
int* a = (int *)malloc(sizeof(int) * N); // go on a heap
```
### 1. 进程
**进程是资源分配的基本单位**，用来管理资源（例如：内存，文件，网络等资源）
进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。**（PCB是描述进程的数据结构）**
下图显示了 4 个程序创建了 4 个进程，这 4 个进程可以并发地执行。
### 2. 线程
线程是独立调度的基本单位。
一个进程中可以有多个线程，它们共享进程资源。
QQ 和浏览器是两个进程，浏览器进程里面有很多线程，例如 HTTP 请求线程、事件响应线程、渲染线程等等，线程的并发执行使得在浏览器中点击一个新链接从而发起 HTTP 请求时，浏览器还可以响应用户的其它事件。
### 3. 区别
（一）拥有资源
进程是资源分配的基本单位，但是线程不拥有资源，线程可以访问隶属进程的资源。
（二）调度
线程是独立调度的基本单位，在同一进程中，线程的切换不会引起进程切换，从一个进程内的线程切换到另一个进程中的线程时，会引起进程切换。
（三）系统开销
由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，所付出的开销远大于创建或撤销线程时的开销。类似地，在进行进程切换时，涉及当前执行进程 CPU 环境的保存及新调度进程 CPU 环境的设置，而线程切换时只需保存和设置少量寄存器内容，开销很小。
（四）通信方面
进程间通信 (IPC) 需要进程同步和互斥手段的辅助，以保证数据的一致性。而线程间可以通过直接读/写同一进程中的数据段（如全局变量）来进行通信。
## 2. 进程状态的切换（生命周期）
#### 2.2 优先级调度
为每个进程分配一个优先级，按优先级进行调度。
为了防止低优先级的进程永远等不到调度，可以随着时间的推移增加等待进程的优先级。
#### 2.3 多级反馈队列
如果一个进程需要执行 100 个时间片，如果采用时间片轮转调度算法，那么需要交换 100 次。
多级队列是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列时间片大小都不同，例如 1,2,4,8,..。进程在第一个队列没执行完，就会被移到下一个队列。这种方式下，之前的进程只需要交换 7 次。
每个队列优先权也不同，最上面的优先权最高。因此只有上一个队列没有进程在排队，才能调度当前队列上的进程。
可以将这种调度算法看成是**时间片轮转调度算法和优先级调度算法**的结合。
### 3. 实时系统
实时系统要求一个请求在一个确定时间内得到响应。
分为**硬实时和软实时**，前者必须满足绝对的截止时间，后者可以容忍一定的超时。
参考资料：
- [操作系统典型调度算法_C语言中文网](http://c.biancheng.net/cpp/html/2595.html)
## 4. 进程同步
### 1. 临界区
**对临界资源进行访问的那段代码称为临界区**。
为了互斥访问临界资源，每个进程在进入临界区之前，需要先进行检查。
```java
// entry section
// critical section;
// exit section
```
### 2. 同步与互斥
- 同步：多个进程按一定顺序执行；
- 互斥：多个进程在同一时刻只有一个进程能进入临界区。
### 3. 信号量
> P 和 V 是来源于两个荷兰语词汇，P() ---prolaag （荷兰语，尝试减少的意思），V() ---verhoog（荷兰语，增加的意思）
信号量（Semaphore）是一个整型变量，可以对其执行 down 和 up 操作，也就是常见的 P 和 V 操作。
- **down** : 如果信号量大于 0 ，执行 -1 操作；如果信号量等于 0，进程睡眠，等待信号量大于 0；（阻塞）
- **up** ：对信号量执行 +1 操作，唤醒睡眠的进程让其完成 down 操作。（唤醒）
down 和 up 操作需要被设计成原语，不可分割，通常的做法是在执行这些操作的时候屏蔽中断。
如果信号量的取值只能为 0 或者 1，那么就成为了 **互斥量（Mutex）** ，0 表示临界区已经加锁，1 表示临界区解锁。
```C++
typedef int semaphore;
semaphore mutex = 1;
void P1() {
down(&mutex);
// 临界区
up(&mutex);
}
void P2() {
down(&mutex);
// 临界区
up(&mutex);
}
```
#### 使用信号量实现生产者-消费者问题
问题描述：使用一个缓冲区来保存物品，只有缓冲区没有满，生产者才可以放入物品；只有缓冲区不为空，消费者才可以拿走物品。
因为缓冲区属于临界资源，因此需要使用一个互斥量 mutex 来控制对缓冲区的互斥访问。
为了同步生产者和消费者的行为，需要记录缓冲区中物品的数量。数量可以使用信号量来进行统计，这里需要使用两个信号量：empty 记录空缓冲区的数量，full 记录满缓冲区的数量。其中，empty 信号量是在生产者进程中使用，当 empty 不为 0 时，生产者才可以放入物品；full 信号量是在消费者进程中使用，当 full 信号量不为 0 时，消费者才可以取走物品。
注意，不能先对缓冲区进行加锁，再测试信号量。也就是说，不能先执行 down(mutex) 再执行 down(empty)。如果这么做了，那么可能会出现这种情况：生产者对缓冲区加锁后，执行 down(empty) 操作，发现 empty = 0，此时生产者睡眠。消费者不能进入临界区，因为生产者对缓冲区加锁了，也就无法执行 up(empty) 操作，empty 永远都为 0，那么生产者和消费者就会一直等待下去，造成死锁。
```c++
#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;
void producer() {
while(TRUE){
int item = produce_item(); // 生产一个产品
// down(&empty) 和 down(&mutex) 不能交换位置，否则造成死锁
down(&empty); // 记录空缓冲区的数量，这里减少一个产品空间
down(&mutex); // 互斥锁
insert_item(item);
up(&mutex); // 互斥锁
up(&full); // 记录满缓冲区的数量，这里增加一个产品
}
}
void consumer() {
while(TRUE){
down(&full); // 记录满缓冲区的数量，减少一个产品
down(&mutex); // 互斥锁
int item = remove_item();
up(&mutex); // 互斥锁
up(&empty); // 记录空缓冲区的数量，这里增加一个产品空间
consume_item(item);
}
}
```
### 4. 管程
管程 (英语：Monitors，也称为监视器) 是一种程序结构，结构内的多个子程序（对象或模块）形成的多个工作线程互斥访问共享资源。
使用信号量机制实现的生产者消费者问题需要客户端代码做很多控制，而管程把控制的代码独立出来，不仅不容易出错，也使得客户端代码调用更容易。
管程是为了解决信号量在临界区的 PV 操作上的配对的麻烦，把配对的 PV 操作集中在一起，生成的一种并发编程方法。其中使用了条件变量这种同步机制。
c 语言不支持管程，下面的示例代码使用了类 Pascal 语言来描述管程。示例代码的管程提供了 insert() 和 remove() 方法，客户端代码通过调用这两个方法来解决生产者-消费者问题。
```pascal
monitor ProducerConsumer
integer i;
condition c;
procedure insert();
begin
// ...
end;
procedure remove();
begin
// ...
end;
end monitor;
```
管程有一个重要特性：在一个时刻只能有一个进程使用管程。进程在无法继续执行的时候不能一直占用管程，否者其它进程永远不能使用管程。
管程引入了 **条件变量** 以及相关的操作：**wait()** 和 **signal()** 来实现同步操作。对条件变量执行 wait() 操作会导致调用进程阻塞，把管程让出来给另一个进程持有。signal() 操作用于唤醒被阻塞的进程。
#### 使用管程实现生产者-消费者问题
```pascal
// 管程
monitor ProducerConsumer
condition full, empty;
integer count := 0;
condition c;
procedure insert(item: integer);
begin
if count = N then wait(full);
insert_item(item);
count := count + 1;
if count = 1 then signal(empty);
end;
function remove: integer;
begin
if count = 0 then wait(empty);
remove = remove_item;
count := count - 1;
if count = N -1 then signal(full);
end;
end monitor;
// 生产者客户端
procedure producer
begin
while true do
begin
item = produce_item;
ProducerConsumer.insert(item);
end
end;
// 消费者客户端
procedure consumer
begin
while true do
begin
item = ProducerConsumer.remove;
consume_item(item);
end
end;
```
## 5. 经典同步问题
生产者和消费者问题前面已经讨论过了。
### 1. 读者-写者问题
允许多个进程同时对数据进行读操作，但是不允许读和写以及写和写操作同时发生。读者优先策略
Rcount：读操作的进程数量（Rcount=0）
CountMutex：对于Rcount进行加锁（CountMutex=1）
WriteMutex：互斥量对于写操作的加锁（WriteMutex=1）
```java
Rcount = 0;
semaphore CountMutex = 1;
semaphore WriteMutex = 1;
void writer(){
while(true){
sem_wait(WriteMutex);
// TO DO write();
sem_post(WriteMutex);
}
}
// 读者优先策略
void reader(){
while(true){
sem_wait(CountMutex);
if(Rcount == 0)
sem_wait(WriteMutex);
Rcount++;
sem_post(CountMutex);
// TO DO read();
sem_wait(CountMutex);
Rcount--;
if(Rcount == 0)
sem_post(WriteMutex);
sem_post(CountMutex);
}
}
```
### 2. 哲学家进餐问题
五个哲学家围着一张圆桌，每个哲学家面前放着食物。哲学家的生活有两种交替活动：吃饭以及思考。当一个哲学家吃饭时，需要先拿起自己左右两边的两根筷子，并且一次只能拿起一根筷子。
**方案一：**下面是一种错误的解法，考虑到如果所有哲学家同时拿起左手边的筷子，那么就无法拿起右手边的筷子，造成死锁。
```java
#define N 5 // 哲学家个数
void philosopher(int i) // 哲学家编号：0 － 4
{
while(TRUE)
{
think(); // 哲学家在思考
take_fork(i); // 去拿左边的叉子
take_fork((i + 1) % N); // 去拿右边的叉子
eat(); // 吃面条中….
put_fork(i); // 放下左边的叉子
put_fork((i + 1) % N); // 放下右边的叉子
}
}
```
**方案二：对拿叉子的过程进行了改进，但仍不正确**
```java
#define N 5 // 哲学家个数
while(1) // 去拿两把叉子
{
take_fork(i); // 去拿左边的叉子
if(fork((i+1)%N)) { // 右边叉子还在吗
take_fork((i + 1) % N);// 去拿右边的叉子
break; // 两把叉子均到手
}
else { // 右边叉子已不在
put_fork(i); // 放下左边的叉子
wait_some_time(); // 等待一会儿
}
}
```
**方案三：等待时间随机变化。可行，但非万全之策**
```java
#define N 5 // 哲学家个数
while(1) // 去拿两把叉子
{
take_fork(i); // 去拿左边的叉子
if(fork((i+1)%N)) { // 右边叉子还在吗
take_fork((i + 1) % N);// 去拿右边的叉子
break; // 两把叉子均到手
}
else { // 右边叉子已不在
put_fork(i); // 放下左边的叉子
wait_random_time( ); // 等待随机长时间
}
}
```
**方案四：互斥访问。正确，但每次只允许一人进餐**
```java
semaphore mutex // 互斥信号量，初值1
void philosopher(int i) // 哲学家编号i：0－4
{
while(TRUE){
think(); // 哲学家在思考
P(mutex); // 进入临界区
take_fork(i); // 去拿左边的叉子
take_fork((i + 1) % N); // 去拿右边的叉子
eat(); // 吃面条中….
put_fork(i); // 放下左边的叉子
put_fork((i + 1) % N); // 放下右边的叉子
V(mutex); // 退出临界区
}
}
```
**正确方案如下：**
为了防止死锁的发生，可以设置两个条件（临界资源）：
- 必须同时拿起左右两根筷子；
- 只有在两个邻居都没有进餐的情况下才允许进餐。
```java
//1. 必须由一个数据结构，来描述每个哲学家当前的状态
#define N 5
#define LEFT i // 左邻居
#define RIGHT (i + 1) % N // 右邻居
#define THINKING 0
#define HUNGRY 1
#define EATING 2
typedef int semaphore;
int state[N]; // 跟踪每个哲学家的状态
//2. 该状态是一个临界资源，对它的访问应该互斥地进行
semaphore mutex = 1; // 临界区的互斥
//3. 一个哲学家吃饱后，可能要唤醒邻居，存在着同步关系
semaphore s[N]; // 每个哲学家一个信号量
void philosopher(int i) {
while(TRUE) {
think();
take_two(i);
eat();
put_tow(i);
}
}
void take_two(int i) {
P(&mutex); // 进入临界区
state[i] = HUNGRY; // 我饿了
test(i); // 试图拿两把叉子
V(&mutex); // 退出临界区
P(&s[i]); // 没有叉子便阻塞
}
void put_tow(i) {
P(&mutex);
state[i] = THINKING;
test(LEFT);
test(RIGHT);
V(&mutex);
}
void test(i) { // 尝试拿起两把筷子
if(state[i] == HUNGRY && state[LEFT] != EATING && state[RIGHT] !=EATING) {
state[i] = EATING;
V(&s[i]); // 通知第i个人可以吃饭了
}
}
```
## 6. 进程通信
进程同步与进程通信很容易混淆，它们的区别在于：
- 进程同步：控制多个进程按一定顺序执行
- 进程通信：进程间传输信息
进程通信是一种手段，而进程同步是一种目的。也可以说，为了能够达到进程同步的目的，需要让进程进行通信，传输一些进程同步所需要的信息。
### * 进程通信方式
#### 直接通信
发送进程直接把消息发送给接收进程，并将它挂在接收进程的消息缓冲队列上，接收进程从消息缓冲队列中取得消息。
Send 和 Receive 原语的使用格式如下：
```cpp
Send(Receiver,message);//发送一个消息message给接收进程Receiver
Receive(Sender,message);//接收Sender进程发送的消息message
```
#### 间接通信
间接通信方式是指进程之间的通信需要通过作为**共享数据结构的实体**。该实体用来暂存发送进程发给目标进程的消息。
发送进程把消息发送到某个中间实体中，接收进程从中间实体中取得消息。这种中间实体一般称为信箱，这种通信方式又称为信箱通信方式。该通信方式广泛应用于计算机网络中，相应的通信系统称为电子邮件系统。
### 1. 管道
管道是通过调用 pipe 函数创建的，fd[0] 用于读，fd[1] 用于写。
```c++
#include
int pipe(int fd[2]);
```
它具有以下限制：
- 只支持半双工通信（单向传输）；
- 只能在父子进程中使用。
僵尸进程测试程序如下所示：
```c
#include
#include
#include
#include
int main()
{
pid_t pid;
pid = fork();
if (pid < 0)
{
perror("fork error:");
exit(1);
}
else if (pid == 0)
{
printf("I am child process.I am exiting.\n");
exit(0);
}
printf("I am father process.I will sleep two seconds\n");
//等待子进程先退出
sleep(2);
//输出进程信息
system("ps -o pid,ppid,state,tty,command");
printf("father process is exiting.\n");
return 0;
}
```
测试结果如下所示：
### 僵尸进程解决办法
- 通过信号机制
- 子进程退出时向父进程发送SIGCHILD信号，父进程处理SIGCHILD信号。在信号处理函数中调用wait进行处理僵尸进程
- fork两次
- 将子进程成为孤儿进程，从而其的父进程变为 init 进程，通过 init 进程可以处理僵尸进程
参考资料：
- [孤儿进程与僵尸进程[总结] - Anker's Blog - 博客园](https://www.cnblogs.com/Anker/p/3271773.html)
## 10. 守护进程
Linux Daemon（守护进程）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。它不需要用户输入就能运行而且提供某种服务，不是对整个系统就是对某个用户程序提供服务。Linux系统的大多数服务器就是通过守护进程实现的。常见的守护进程包括系统日志进程syslogd、 web服务器httpd、邮件服务器sendmail和数据库服务器mysqld等。
守护进程一般在系统启动时开始运行，除非强行终止，否则直到系统关机都保持运行。守护进程经常以超级用户（root）权限运行，因为它们要使用特殊的端口（1-1024）或访问某些特殊的资源。
一个守护进程的父进程是init进程，因为它真正的父进程在fork出子进程后就先于子进程exit退出了，所以它是一个由init继承的孤儿进程。守护进程是非交互式程序，没有控制终端，所以任何输出，无论是向标准输出设备stdout还是标准出错设备stderr的输出都需要特殊处理。
守护进程的名称通常以d结尾，比如sshd、xinetd、crond等
编写守护进程的一般步骤步骤：
1. 在父进程中执行 fork 并 exit 推出；
2. 在子进程中调用 setsid 函数创建新的会话；
3. 在子进程中调用 chdir 函数，让根目录 `/` 成为子进程的工作目录；
4. 在子进程中调用umask函数，设置进程的umask 为 0；
5. 在子进程中关闭任何不需要的文件描述符
参考资料：
- [守护进程概念，以及怎么创建守护进程 - CSDN博客](https://blog.csdn.net/one_piece_hmh/article/details/52770111)
## 11. 上下文切换
上下文切换，有时也称做**进程切换或任务切换**，是指CPU从一个进程或线程切换到另一个进程或线程。 在操作系统中，CPU 切换到另一个进程需要保存当前进程的状态并恢复另一个进程的状态：当前运行任务转为就绪（或者挂起、删除）状态，另一个被选定的就绪任务成为当前任务
# 三、死锁
> 资源分类：（1）可重用资源；（2）消耗资源
## 1. 什么是死锁
造成死锁的原因就是多个线程或进程对同一个资源的争抢或相互依赖。一个最简单的解释就是你去面试，面试官问你告诉我什么是死锁，我就录用你，你回答面试官你录用我，我告诉你。
如果一个进程集合里面的每个进程都在等待只能由这个集合中的其他一个进程（包括他自身）才能引发的事件，这种情况就是死锁。
这个定义可能有点拗口，下面用一个简单例子说明。
资源 A、B，进程 C、D 描述如下：
资源 A 和资源 B，都是不可剥夺资源，现在进程 C 已经申请了资源 A，进程 D 也申请了资源 B，进程 C 接下来的操作需要用到资源 B，而进程 D 恰好也在申请资源A，进程 C、D 都得不到接下来的资源，那么就引发了死锁。
**然后套用回去定义**：如果一个进程集合里面（进程 C 和进程 D）的每个进程（进程 C 和进程 D）都在等待只能由这个集合中的其他一个进程（对于进程 C，他在等进程 D；对于进程 D，他在等进程 C）才能引发的事件（释放相应资源）。
这里的资源包括了软的资源（代码块）和硬的资源（例如扫描仪）。
资源一般可以分两种：**可剥夺资源（Preemptable）**和**不可剥夺资源 （Nonpreemptable）**。一般来说对于由可剥夺资源引起的死锁可以由系统的重新分配资源来解决，所以一般来说大家说的死锁都是由于不可剥夺资源所引起的。
## 2. 死锁的必要条件
上图 c 为不安全状态，因此算法会拒绝之前的请求，从而避免进入图 c 中的状态。
（三）多个资源的银行家算法
上图中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的 E、P 以及 A 分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如 A=(1020)，表示 4 个资源分别还剩下 1/0/2/0。
检查一个状态是否安全的算法如下：
- 查找右边的矩阵是否存在一行小于等于向量 A。如果不存在这样的行，那么系统将会发生死锁，状态是不安全的。
- 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到 A 中。
- 重复以上两步，直到所有进程都标记为终止，则状态时安全的。
如果一个状态不是安全的，需要拒绝进入这个状态。
## 4. 如何在写程序的时候就避免死锁
> 网易有道面经
所谓的死锁呢，发生的主要原因在于了有多个进程去竞争资源，也就是同时去抢占。
可以自己写一个支持多线程的消息管理类，单开一个线程访问独占资源，其它线程用消息交互实现间接访问。
这种机制适应性强、效率高，更适合多核环境。
# 四、内存管理
## 1. 虚拟内存
虚拟内存的目的是为了让物理内存扩充成更大的逻辑内存，从而让程序获得更多的可用内存。
为了更好的管理内存，操作系统将内存抽象成地址空间。每个程序拥有自己的地址空间，这个地址空间被分割成多个块，每一块称为一页。这些页被映射到物理内存，但不需要映射到连续的物理内存，也不需要所有页都必须在物理内存中。当程序引用到一部分不在物理内存中的地址空间时，由硬件执行必要的映射，将缺失的部分装入物理内存并重新执行失败的指令。
从上面的描述中可以看出，虚拟内存允许程序不用将地址空间中的每一页都映射到物理内存，也就是说一个程序不需要全部调入内存就可以运行，这使得有限的内存运行大程序称为可能。例如有一台计算机可以产生 16 位地址，那么一个程序的地址空间范围是 0~64K。该计算机只有 32KB 的物理内存，虚拟内存技术允许该计算机运行一个 64K 大小的程序。
