OS

用户态和内核态

Intel的CPU将特权级别分为4个级别：RING0,RING1,RING2,RING3。

linux内核跑在ring 0级，用户程序跑在ring 3，对于系统的关键访问，需要经过kernel的同意，保证系统健壮性。

内核执行的操作： 200多个系统调用，比如： sendfile read write pthread fork 等。

JVM也是跑在ring 3上的，站在操作系统的角度，JVM就是个普通程序。

进程线程纤程中断

Q: 进程和线程的区别？

通俗的讲：进程是一个程序运行起来的状态，线程是进程中不同的执行路径；

专业的表述：进程是系统资源分配的基本单位，线程是系统资源调度的基本单位。

分配资源最重要的是：独立的内存空间，线程调度执行（线程共享进程的内存空间，没有自己独立的内存空间）

线程是怎么实现的？

在Linux中：线程就是一个普通的进程，只不过和其他进程共享资源（内存空间、全局数据等）；
在其他系统中，是一个轻量级进程，都有各自所谓的LWP（Light Wight Process）的实现

纤程（Fiber）

用户态的线程，线程中的线程，切换和调度不需要经过OS

优势：

占用资源很少，OS中起一个线程大概需要1M内存，Fiber只需要4K；
非常轻量，切换比较简单；
可以启动很多很多个，10w+没有问题。

目前支持内置纤程的语言：Kotlin、Scala、Go、Python(lib)...

Java中对线程的支持，没有内置，可以利用Quaser库，不过不太成熟。

纤程的应用场景：

很短的计算任务，不需要和内核打交道，并发量高，可以使用纤程。

进程

linux中也称为task，是系统资源分配的基本单位。

进程描述符：PCB（Process Control Block）

每个进程在linux内部都有一个数据结构PCB，用来描述跟踪它，Linux用它来管理进程。

进程的创建和启动

linux中可以通过系统函数fork() exec()来创建和启动。

从A进程中fork B的话，那么A称之为B的父进程。

僵尸进程

父进程产生子进程后，会维护子进程的一个PCB结构，子进程退出，由父进程进程释放；

如果父进程没有释放，那么子进程将会成为一个僵尸进程。

其实也就只有子进程的PCB没有被释放，子进程的其他资源已经随着子进程退出释放了，一般情况下不会有什么影响，但是如果有很大量的僵尸进程，还是会有影响的。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>

int main() {
        pid_t pid = fork();
  
        if (0 == pid) {
                printf("child id is %d\n", getpid());
                printf("parent id is %d\n", getppid());
        } else {
                while(1) {}
        }
}

孤儿进程

在子进程结束之前，父进程已经退出了；

一般情况下（命令行模式），孤儿进程会成为init进程的孩子，由1号进程维护。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>

int main() {
        pid_t pid = fork();

        if (0 == pid) {
                printf("child ppid is %d\n", getppid());
                sleep(10);
                printf("parent ppid is %d\n", getppid());
        } else {
                printf("parent id is %d\n", getpid());
                sleep(5);
                exit(0);
        }
}

进程调度

Linux2.5 经典Unix O(1)调度策略，偏向服务器，但对UI交互不太友好。

平分时间片，轮询的策略。

Linux2.6.23 采用CFS 完全公平调度算法 Completely Fair Scheduler

按优先级分配时间片的比例，记录每个进程的执行时间，如果有一个进程的执行时间不到它应该被分配的比例，则优先执行。

进程调度的基本概念

进程类型
- IO密集型：大部分时间用于等待IO
- CPU密集型：大部分时间用于计算
进程优先级
- 实时进程：永远大于普通进程，并且又分0 - 99的优先级
- 普通进程：也分-20 - 19的优先级

Linux默认的调度策略

对于实时进程：使用 SCHED_FIFO(First In First Out)和 SCHED_RR(Round Robin)，优先级高采用 SCHED_FIFO优先执行，同级别的采用 SCHED_RR轮询

对于普通进程：使用CFS

中断

中断是硬件跟操作系统内核打交道的一种机制。

软中断（80中断） == 系统调用

系统调用：int 0x80 或者sysenter原语，通过ax寄存器填入调用号

参数通过bx cx dx si di寄存器传入内核，返回值通过ax寄存器返回

java读网络 – jvm read() –> c库read() - > 内核空间 -> system_call() （系统调用处理程序）-> sys_read()

从汇编角度理解软中断

搭建汇编环境
```
yum install nasm
```

编写汇编代码，使用软中断在标准输出上输出“Hello”字符串

;hello.asm
;write(int fd, const void *buffer, size_t nbytes)
;fd 文件描述符 file descriptor - linux下一切皆文件

section data
    msg db "Hello", 0xA
    len equ $ - msg

section .text
global _start
_start:

    mov edx, len
    mov ecx, msg
    mov ebx, 1 ;文件描述符1 std_out
    mov eax, 4 ;write函数系统调用号 4
    int 0x80

    mov ebx, 0
    mov eax, 1 ;exit函数系统调用号
    int 0x80

编译
```
nasm -f elf hello.asm -o hello.o
```
链接
```
ld -m elf_i386 -o hello hello.o
```
执行
```
./hello
```

内存管理

内存管理的发展历程

DOS时代：同一时间只能有一个进程在运行（也有一些特殊算法支持多进程）

windows9x - 多个进程直接装入内存，会存在两个问题，1：内存不够用 2：互相打扰

为了解决这两个问题，诞生了现在的内存管理系统：虚拟地址分页装入软硬件结合寻址

分页（内存不够用），内存中分成固定大小的页框（4K），把程序（硬盘上）分成4K大小的块，用到哪一块，加载那一块，加载的过程中，如果内存已经满了，会把最不常用的一块放到swap分区，把最新的一块加载进来，这个就是著名的LRU算法（Least Recently Used 最不常用）
1. LRU算法 LeetCode146题
2. 哈希表（保证查找操作O(1)） + 链表（保证排序操作和新增操作 O(1)））
3. 双向链表（保证左边指针指向右边块）
虚拟内存（解决相互打扰问题）
1. Dos、Win31...相互可以访问对方的内存，甚至操作系统，可以把对方干掉
2. 为了保证互不影响，让进程工作在虚拟空间，程序中用到的空间地址不再是直接的物理地址，而是虚拟地址，这样A进程永远无法访问B进程的空间
3. 虚拟空间有多大？就是寻址空间大小，64位系统就是2^64byte，比物理空间大很多
4. 站在虚拟的角度，进程是独享整个系统和CPU的
5. 内存映射：虚拟内存映射到物理内存的过程叫做内存映射
  
  偏移量 + 段的基地址 = 线性地址（虚拟空间内）
  
  线性地址通过**OS + MMU（硬件：Memory Management Unit）**映射到物理地址
缺页中断

需要用到的页在内存中没有，产生缺页异常（中断），由内核处理并加载

为什么使用虚拟内存？
1. 隔离应用程序
  
  每个程序都认为自己拥有连续可用的内存
  
  突破物理内存的限制
  
  应用程序不需要考虑物理内存是否够用，是否能够分配等底层问题
2. 安全
  
  保护物理内存，不被恶意程序访问

CPU是如何区分一个立即数和一条指令的？

计算机总线内部分为数据总线、地址总线、控制总线。

通过数据总线传输则认为是立即数。
通过地址总线传输则认为是内存地址，地址总线为48位(主板阉割)。
通过控制总线传输则认为是指令。

内核同步机制

关于同步理论的一些基本概念

临界区（critical area）: 访问或操作共享数据的代码段简单理解：synchronized大括号中部分（原子性）
竞争条件（race conditions）两个线程同时拥有临界区的执行权
数据不一致：data unconsistency 由竞争条件引起的数据破坏
同步（synchronization）避免race conditions
锁：完成同步的手段（门锁，门后是临界区，只允许一个线程存在）上锁解锁必须具备原子性
原子性（象原子一样不可分割的操作）
有序性（禁止指令重排）
可见性（一个线程内的修改，另一个线程可见）

互斥锁排他锁共享锁分段锁

内核同步常用方法

原子操作 – 内核中类似于AtomicXXX，位于<linux/types.h>
自旋锁 – 内核中通过汇编支持的cas，位于<asm/spinlock.h>
读-写自旋 – 类似于ReadWriteLock，可同时读，只能一个写读的时候是共享锁，写的时候是排他锁
信号量 – 类似于Semaphore(PV操作 down up操作占有和释放）重量级锁，线程会进入wait，适合长时间持有的锁情况
读-写信号量 – downread upread downwrite upwrite （多个写，可以分段写，比较少用）(分段锁）
互斥体(mutex) – 特殊的信号量（二值信号量）
完成变量 – 特殊的信号量（A发出信号给B，B等待在完成变量上） vfork() 在子进程结束时通过完成变量叫醒父进程类似于(Latch)
BKL：大内核锁（早期，现在已经不用）
顺序锁（2.6）： – 线程可以挂起的读写自旋锁序列计数器（从0开始，写时增加(+1)，写完释放(+1)，读前发现单数，说明有写线程，等待，读前读后序列一样，说明没有写线程打断）
禁止抢占 – preempt_disable()
内存屏障 – 见volatile

计算机软件底层知识

OS