零拷贝

传统的IO模型 read(),write(),文件发送到网络，需要经过四次拷贝，四次上下文切换：

磁盘---->内核缓冲区---->用户缓冲区---->socket内核缓冲区---->网卡

其中第一次和最后一次是DMA拷贝，中间两次是CPU拷贝

DMA——Direct Memory Access直接内存访问。让硬件设备直接把数据搬到内存，而不是CPU一个字节一个字节的搬运

为了提高这个过程的效率，零拷贝技术诞生了。零拷贝旨在通过一次系统调用，将磁盘读取和网络传输合并为一个操作。减少上下文的切换，减少了内存拷贝的次数

Linux下，常见的零拷贝方式有两种： sendfile，mmap

mmap

mmap实际上减少了一次内核到用户空间拷贝

磁盘---->内核缓冲区---->用户缓冲区---->socket内核缓冲区---->网卡

还是这个过程，mmap通过让用户空间和内核页映射同一块物理地址，从而访问到磁盘内数据，减少了一次数据从内核到用户态的拷贝。 所以mmap实际上是3次拷贝

磁盘---->用户缓冲区---->socket内核缓冲区---->网卡

sendfile

sendfile实际上也是只减少了一次拷贝，相比较于mmap，sendfile直接将数据从内核缓冲区拷贝到socket缓冲区

磁盘---->内核缓冲区---->socket内核缓冲区---->网卡

这个过程实际上也是三次拷贝，但是在现代Linux中，sendfile可以优化，实现类似于

磁盘---->socket内核缓冲区---->网卡

两次拷贝都是DMA拷贝而没有CPU拷贝，实现真正的零CPU拷贝，所以一般说sendfile可以实现真正的零拷贝

而sendfile一般通过Scatter-Gather的方式实现这种功能。sendfile认为既然用户程序不修改文件内容，只是复制文件，那为什么非要把文件拷贝到用户缓冲区？所以直接将数据从内核缓冲区拷贝到socket缓冲区。Scatter-Gather则认为这一步也可以省略，可以从内核缓冲区到socket而不需要CPU拷贝。 Scatter-Gather的思想是不要求数据必须连续存放，允许一次IO操作操作多个不连续的区域，Scatter-Gather中前者是分散的意思，后者是聚集的意思。所以一个IO操作可以引用多个不连续的内存区域，而不需要先把他们复制成一块连续内存。

磁盘
 │
 │ DMA
 ↓
内核页缓存
 │
 │ 直接引用这些页面
 ↓
Socket
 │
 │ DMA
 ↓
网卡

计算机分级存储

计算机的存储有一个特点：速度快的存储设备，通常容量小，价格贵。而容量大，价格便宜的存储设备一般存储速度会比较慢。 计算机的分级存储从快到慢：

CPU寄存器 -> CPU cache -> 内存RAM -> SSD -> HDD
                |
             L1 L2 L3

cache：cache的存在满足局部性原理

• 时间局部性，即一个刚刚被访问的数据，有可能很快再次被访问。放在cache中非常划算，可以防止大量未命中
• 空间局限性：一个数据被访问，他周围的数据也有可能被访问，cpu可能把一块连续的内存放入cache。顺序读取后续数据会比随机访问快 对于L1，L2，L3cache来说，距离越远，容量越大，操作速度越慢。但是一般每个CPU都有自己的L1，而在很多CPU中L3是多个CPU共享的 内存RAM：内存断电之后容易丢失，是易失型存储。程序运行时主要在内存内运行 如果内存不够程序运行，操作系统会把暂时不用的资源放到磁盘，这个称为SWAP。但交换空间严格意义上不算内存，只是用硬盘模拟内存 SSD：固态硬盘，里面的数据断电不会丢失，内部主要使用闪存falsh memory HDD：机械硬盘，读取数据需要磁盘旋转，移动磁头，找到数据，读取数据，随机访问会比较慢

      磁头
       ↓
    ───────
   /       \
  |  磁盘   |
   \       /
    ───────
       ↻

数据访问的时候先访问三级cache，如果都没有的话，查询Ram内存，如果内存中也没有的话，那可能发生缺页异常。操作系统发现这个数据不在物理内存，从SSD/HDD里面加载数据，然后逐级上传，缓存，最后存入CPU寄存器

接下来主要对计算机中的内存部分展开讲解，设置虚拟内存->物理内存映射，页表，堆栈，零拷贝等

内存

对于操作系统来说物理内存是固定的，为每个程序指定一块连续内存，如果后续需要扩容或缩减。就涉及到对其他地址数据的修改。处理起来会比较麻烦。对此，操作系统为每个进程分配一个页表，用页表的虚拟地址对物理地址进行映射。

虚拟内存

虚拟内存可以很好的解决：

• 进程间地址冲突的问题，每个进程维护自己的页表，并且没有办法访问其他进程的页表。
• 运行内存超过物理内存实际大小的问题，因为程序运行符合局部性原理，CPU访问内存有很明显的重复访问的倾向。对于长期大量未访问的数据，可以把它放到硬盘
• 标记状态，页表除了地址，还存放了进程对对一个页的状态以及权限记录位，可以标记页是否存在，对页的读写权限之类的。

页表存储在内存里，由MMU做内存管理操作

页表

页表的操作过程，以二级页表为例： 从页目录表中拿到页表位置，通过页表中的对应位置拿到物理页位置，物理页页号*页大小加偏移地址就是实际的物理地址，如果用段表做映射，就是段基址 * 16+偏移地址

页表和段表有什么区别呢

页表用页来映射，大小一般是固定的，初始一个页是4kb。而且页表不关心自己映射的东西具体是什么，堆？栈？或者代码，页不在乎，只是映射… 段表用段来进行映射，段不确定大小。分段的思想本上就有一些逻辑划分，代码段，堆段，栈段可以存放不同的数据。 一般用页来映射而不用段，因为分段可能产生外部碎片，总空闲空间足够，但是会产生很多小块，而没有一块连续可用的空间。而分页也不是完美的，可能产生内部碎片

程序的内存布局

这里从低到高分别是： 代码段：包括二进制可执行代码 数据段：包括已初始化的静态变量和全局变量 BSS段：包括未初始化的全局变量和静态变量 堆段：包括动态分配的内存，从低地址开始向上增长 文件映射段：包括动态库，共享内存等 栈段：包括局部变量和程序的上下文，栈的大小一般是固定的8MB

程序有自己的虚拟内存布局，里面有代码、数据、BSS、堆、内存映射区、栈等区域；现代 Linux 再通过分页机制，把这些虚拟地址映射到物理内存。

堆和栈有什么区别

分配方式：堆是动态内存分配，由程序员主动申请或者释放内存，栈是静态分配内存，由编译器申请或者释放内存 内存管理：堆需要程序员手动管理或者释放内存，管理不当可能产生内存泄漏，栈由编译器自动管理内存，遵循后进先出，变量的生命周期由他的作用域决定

copy on write

主进程fork的时候，操作系统会把父进程的页表copy一份给子进程，子进程拥有的页表和父进程拥有的页表指向的是同一块虚拟内存。但是子线程对该页表只有只读权限。这个是为了防止写过程太长导致父子进程创建的时候长时间阻塞。 copy on write还一定程度上节省了物理内存资源，子进程想要拥有父进程的资源，不需要复制一份同样的资源，而是复制一份页表。父子进程任意一方对这个进程进行修改，才会触发写时复制

malloc

程序触发malloc的时候，会分配一片虚拟内存，具体操作是： 先brk()，移动堆指针指定一块区域，再mmap()通过私有匿名映射（供进程自己使用，不关联任何磁盘文件）来获取一块文件映射区的内存 当程序访问这一块内存，就会寻找这一块虚拟内存对应的物理内存。此时会发生缺页中断。进程从用户态切换到内核态，移交缺页中断执行

缺页中断检查是否有空闲的物理内存，如果有，就分配物理内存。如果没有空闲的内存，那么内核会先回收内存。

如果回收之后内存依旧不够，那么会触发OOM机制： OOM机制根据算法选择一个物理内存占用最高的进程，杀死进程，重复操作直到有足够的内存空间。

内存回收

内存回收主要回收两类： 文件页：内核缓存的磁盘数据，内核缓存的文件数据。都可以叫作文件页。针对脏页——修改过但还没有写入磁盘的数据，就需要先写入磁盘，再释放内存。回收干净页则可以直接释放。 匿名页：这部分内存没有实际载体，回收通过上文提到的SWAP机制，先把一部分内存写入磁盘，再释放内存，需要的时候再从磁盘取出来。

文件页的回收和匿名页的回收都基于LRU算法：优先回收不常访问的内存，维护两个双向链表 active_list:活跃内存页链表，存放的是最近活跃的内存页 inactive——list：不活跃内存链表，存放最近不活跃的内存页 越接近尾部，代表越不活跃 收起

锁

竞态条件是指当多个线程同时访问和修改同一块未被保护的内存区域的时候，最终结果依赖于线程的执行顺序，可能导致数据的不一致 为了保护共享资源，确保共享资源同一时间只有一个线程可以修改，用锁来保护。锁分很多类型

自旋锁

对于一个用自旋锁保护的资源，线程抢锁失败之后，会忙等待，直到它拿到锁。 自旋锁不会主动产生上下文切换，是在用户态进行由硬件封装的原子指令，包含

• 检查锁的状态
• 将锁设置为当前线程持有 两个步骤。忙等待可以用while循环实现，最好用pause实现，可以减少循环等待时候的耗电量。 自旋锁的好处是没有上下文的切换，加锁解锁很快。缺点是忙等待期间一直占用CPU资源，锁很长时间会浪费CPU，而且临界区非常短 (临界区就是指被锁住的，只能一个线程访问修改的那一段代码)

互斥锁

线程如果拿不到互斥锁，那么阻塞挂起等待。等待持有锁的线程释放锁之后唤醒等待线程。在linux中由futex唤起 互斥锁的好处是不会长时间占用CPU，适合临界区比较长。但是阻塞唤醒有开销，线程上下文切换也有开销。

读写锁

允许多个线程同时读，但是只要写操作到来，立刻阻塞读线程和读操作，同时也不允许其他写操作进行 读写锁适合多读少写的场景，但是实现比较复杂，而且锁本身有管理开销，写操作很多的时候性能不如互斥锁。

乐观锁

乐观锁偏向于一种实现思想，乐观锁认为大多数时间不会发生冲突。对于一个值，先检查，再修改，然后提交操作，如果不冲突则认为成功，反之认为失败。 举一个KV的例子，在MVCC场景下，存入一个建 key：name，value：1，expectversion：1，那么操作先检查当前建版本是否为1，如果是则修改，否则建修改认为失败 乐观锁不需要一直持有锁，并发性能好，在冲突小的场景下效率很高，但是高并发高冲突场景下要不断重试。而且存在ABA问题 ABA问题就是一个线程检查CAS，为A则修改。但是在检查到A之后挂起等待。此时另一个线程修改值为B，再修改回A，原线程恢复执行，虽然值还是A，但是实际上已经发生修改，这样的问题可以用检查值+全局版本号的方法解决

悲观锁

悲观锁和乐观锁一样属于一种实现思想，但是完全相反。悲观锁认为冲突一定会发生，所以要求每次操作都先锁住临界区，然后操作，最后释放锁。

SELECT * FROM product
WHERE id = 1
FOR UPDATE;

上面的例子是一个锁定读，加一个排它锁（和互斥锁不完全一样）

产生死锁的四个条件

1. 互斥条件
2. 持有并等待条件(A持有1条件等待2，B持有条件2等待1)
3. 不可剥夺条件，在这个线程主动释放之前条件不被其他线程获取
4. 环状链条件，在发生死锁的时候，两个线程顺序构成了环状链

怎么避免死锁

只要破坏上述四个条件中的一个，就可以避免死锁。一般采用资源有序分配法。也就是对于获取同样临界区资源的AB两个线程，都是先获取1资源再获取2资源。保证这个顺序一致

银行家算法

银行家算法是一种有效避免死锁的算法，其要求如下：

• 总量约束：一个进程的最大需求量不能超过系统拥有的总资源量
• 可分期请求：一个进程可以分期请求资源，但需要满足总量约束
• 推迟分配：当系统拥有的资源小于进程需求的时候，可以延迟分配资源给进程，让进程在有限的时间内获取资源

银行家算法的思想就是：在分配资源给进程之前，检查分配之后的安全性，通过预执行判断是否会产生死锁。如果系统能满足该进程的资源要求，则分配，否则等待 不断检查剩余可用资源是否满足某个最大线程的最大需求，并将满足的进程加入安全序列，回收该进程所持有的资源。重复这个过程，直到所有进程都被加入安全序列。安全状态一定不会发生死锁，不安全状态不一定会发生死锁。 收起