基础：Linux是怎么管理内存的

旧城等待， 2022-09-17 03:03 168阅读 0赞

> 同 CPU 管理⼀样，内存管理也是操作系统最核⼼的功能之⼀。内存主要⽤来存储系统和应⽤程序的指令、数据、缓存等。

# 内存映射 #

我们通常所说的内存容量，比如8GB，其实指的就是物理内存。**物理内存也称为主存，⼤多数计算机⽤的主存都是动态随机访问内存（DRAM）。只有内核才能直接访问物理内存**

> 那么，进程要访问内存时，该怎么办呢？

*  Linue内核给每个进程提供了一个独立的虚拟地址空间，并且这个地址空间是连续的。
 *  这样，进程就可以很方便的访问内存，更确切的说是访问虚拟内存

虚拟地址空间的内部又被分为**内核空间和用户空间**两部分，不同字长(也就是单个CPU指令可以处理数据的最大长度)的处理器，地址空间的范围不同。比如最常见的32为和64为系统，下面的虚拟地址空间如下图：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_18_color_FFFFFF_t_70_g_se_x_16]

*  从上面可以看出，32位系统的内核空间占用1G，位于最高处，剩下3G是用户空间
 *  64位系统的内核空间和用户空间都是128T，分别占据整个内存空间的最高处和最低处，剩下的中间部分是未定义的

我们知道：

*  进程在用户态时，只能访问用户空间内存
 *  只有进入内核态后，才可以访问内核空间内存。

**虽然每个进程的地址空间都包含了内核空间，但这些内核空间，其实关联的都是相同的物理内存**。这样，进程切换到内核态后，就可以很方便的访问内核空间内存

既然每个进程都有这么大的地址空间，那么所有进程的虚拟内存加起来，自然要比实际的物理内存大得多。所以，**并不是所有的虚拟内存都会分配内存，只有那些实际使用的虚拟内存才分配物理内存，并且分配后的物理内存，是通过内存映射来管理的**

内存映射，其实就是**将虚拟地址映射到物理内存地址。为了完成内存映射，内核为每个进程都维护了一张页表，记录虚拟地址到物理地址的映射关系**：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_16_color_FFFFFF_t_70_g_se_x_16]

*  页表实际上存储在CPU的内存管理单元MMU中。这样，正常情况下，处理器就可以直接通过硬件，找出要访问的内存。
 *  而当进程访问的虚拟地址在页表中查不到时，系统就会产生一个**缺页异常**，进入内核空间分配物理内存、更新进程页表，最后在返回用户空间，恢复进程的运行

> 这里就可以解释TLB(后备缓冲区)是怎么影响CPU的内存访问性能了：

MMU全称就是内存管理单元，管理地址映射关系（也就是⻚表）。但MMU的性能跟CPU⽐还是不够快，所以⼜有了TLB。TLB实际上是MMU的⼀部分，把⻚表缓存起来以提升性能

*  TLB其实就是MMU中页表的高速缓存。
 *  由于进程的虚拟地址空间是独立的，而TLB又比MMU快得多，所以，通过减少进  
    程的上下文切换，减少TLB缓存的使用率，进而提高CPU的内存访问性能。

> 如果进程间的虚拟内存空间独⽴，每个进程⼜有⾃⼰的⻚表，那么进程怎么获知其他进程占⽤的物理内存情况，怎么防⽌覆盖其他进程的物理内存块呢？

*  进程不需要获取其他进程的内存情况
 *  所有进程的内存都是有内核来管理的，内核保证内存的访问安全。比如，访问非法地址时，进程会panic

> MMU以页为单位管理内存

*  MMU并不以字节为单位来管理内存，而是规定了一个内存映射的最小单位，也就是页，通常是4KB大小。这样，每一次内存映射，都需要关联4KB或者4KB整数倍的内存空间
 *  页的大小只有4KB，导致的另一个问题就是，整个页表会变得非常大。比如，仅 32 位系统就需要 100 多万个⻚表项（4GB/4KB），才可以实现整个地址空间的映射。

为了解决⻚表项过多的问题，Linux 提供了两种机制，也就是多级⻚表和⼤⻚（HugePage）。

*  多级页表就是把内存分成区块来管理，将原来的映射关系改成区块索引和区块内的偏移。
    
     *  由于虚拟内存空间通常只用了很少的一部分，那么，多级页表就只需要保存这些使用中的区块，这样就可以大大减少页表的项数。
     *  Linux ⽤的正是四级⻚表来管理内存⻚，如下图所示，虚拟地址被分为5个部分，前4个表项⽤于选择⻚，⽽最后⼀个索引表示⻚内偏移。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16]

*  再看⼤⻚，顾名思义，就是比普通页更大的内存块，常见的大小有2MB和1GB。大页通常用在大量内存的进程上，比如Oracle，DPDK等。

通常这些机制，在页表的映射下，进程就可以通过虚拟地址来访问内存了。那么具体到一个Linux进程中，这些内存又是怎么使用的呢？

# 虚拟内存空间分布 #

首先，我们需要进一步了解虚拟内存空间的分布情况。最上面的内核空间不用多讲，而用户空间内存，其实又被分成了多个不同的段。以32位的系统为例，它们的关系如下：

*  只读段，包括代码和常量等等
 *  数据段，包括全局变量等
 *  堆，包括动态分配的内存，从低地址开始向上增长
 *  文件映射段，包括动态库，共享内存等，从高地址开始向下增长
 *  栈，包括局部变量和函数调用上下文等。占的大小是固定的，一般为8MB  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_9_color_FFFFFF_t_70_g_se_x_16]

在这五个内存段中，堆和文件映射段是动态分配的，比如，使⽤ C 标准库的 malloc() 或者 mmap() ，就可以分别在堆和⽂件映射段动态分配内存。

其实64位系统的内存分布也类似，只不过内存空间要⼤得多。那么，更重要的问题来了，内存究竟是怎么分配的呢？

# 内存分配和回收 #

malock()是C标准库提供的内存分配函数，对应到系统调用上，有两种实现方式，即brk()和mmap()

*  对于小块内存(小于128K)，C标准库使用brk()来分配，也就是通过移动堆顶的位置来分配内存。这些内存释放后并不会立即归还系统，而是被缓存起来，这样就可以重复使用
 *  对于大块内存(大于128K)，则直接使用内存映射mmap()来分品牌，也就是在文件映射段找一块空闲内存分配出去。

这两种方式，各有优缺点：

*  brk()方式的缓存，可以减少缺页异常的发生，提高内存访问效率。不过，由于这些内存没有归还系统，在内存工作繁忙时，频繁的内存分配和释放会造成内存碎片
 *  mmap()方式分配的内存，会在释放时直接归还，所以每次mmap都会发生缺页异常。在内存工作繁忙时，频繁的内存分配会导致大量的缺页异常，使得内核的管理负担增大。这也是malloc只对大块内存使用mmap的原因

另外，**当这两种调用发生后，其实并没有真正的分配内存。这些内存，都只在首次访问时才分配，也就是通过缺页异常进入内核中，再由内核来分配内存**

整体来说，Linux使用伙伴系统来管理内存的分配。伙伴系统和MMU一样，都是以页为单位来管理内存，并通过相邻页的合并，来减少内存碎片化(比如brk方式造成的内存碎片)。

> 问题：如果遇到比页更小的对象，比如不到1k的时候，该怎么分配内存呢？

*  实际系统运行中，确实有大量比页还小的对象，如果也为它们分配单独的页，那就太浪费内存了。
 *  所以，在用户空间中，**malloc通过brk()分配的内存，在释放时并不立即归还给系统，而是缓存起来重复利用**。在内核空间，Linux通过`slab`分配器来管理小内存。你可以把slab看成构建在伙伴系统上的一个缓存，主要作用就是分配并释放内核空间中的小对象。（slab是内核空间的，只⽤来管理内核中的⼩块内存，⽤户空间malloc不会使⽤slab机制）
 *  对内存来说，如果只分配而不释放，就会造成内存泄露，甚至会耗尽系统内存。所以在应用程序⽤完内存后，还需要调⽤free() 或 unmap() ，来释放这些不⽤的内存。

当然，系统也不会任由某个进程用完所有的内存。在发现内存紧张的时候，系统就会通过一系列机制来回收内存。比如下面三种方式：

*  基于LRU算法，回收缓存（最近使用最少的内存页面）
 *  基于swap机制，回收不常访问的内存，把不常用的内存通过交换分配直接写到磁盘中
 *  基于OOM机制，，直接杀掉占用大量内存的进程

> 关于swap

其中，第二种方式回收不常访问的内存时， 会⽤到交换分区（以下简称 Swap）

*  Swap其实就是把一块磁盘空间当成内存来用。它可以把进程暂时不用的数据存储到磁盘中(这个过程称为换出)，当进程访问这些内存时，再从磁盘读取这些数据到内存中(这个过程叫做换入)
 *  所以，你可以发现，Swap 把系统的可⽤内存变⼤了。不过要注意，**通常只在内存不⾜时，才会发⽣ Swap 交换。并且由于磁盘读写的速度远⽐内存慢，Swap 会导致严重的内存性能问题**。

> 关于LRU

缓存回收和swap回收，实际上都是基于LRU算法，也就是优先回收不常访问的内存。LRU回收算法，实际上维护这active和inactive这两个双向链表：

*  active 记录活跃的内存⻚
 *  inactive 记录⾮活跃的内存⻚。

越接近链表尾部，就表示内存⻚越不常访问。这样，在回收内存时，系统就可以根据活跃程度，优先回收不活跃的内存。

活跃和非活跃的内存页，按照类型的不同，又分别对应文件页和匿名页，对应着缓存回收和swap回收。

当然，你可以从 /proc/meminfo 中，查询它们的⼤⼩，⽐如：

# grep表示只保留包含active的指标（忽略⼤⼩写）
    # sort表示按照字⺟顺序排序
    $ cat /proc/meminfo | grep -i active | sort
    Active(anon): 167976 kB
    Active(file): 971488 kB
    Active: 1139464 kB
    Inactive(anon): 720 kB
    Inactive(file): 2109536 kB
    Inactive: 2110256 kB

> 关于OOM

第三种⽅式提到的 OOM（Out of Memory），其实是内核的一种保护机制。它监控进程的内存使用情况，并且使用oom\_score为每个进程的内存使用情况进行评分：

*  ⼀个进程消耗的内存越⼤，oom\_score 就越⼤；
 *  ⼀个进程运⾏占⽤的 CPU 越多，oom\_score 就越⼩。

这样，进程的 oom\_score 越⼤，代表消耗的内存越多，也就越容易被 OOM 杀死，从⽽可以更好保护系统。

*  当然，为了实际⼯作的需要，管理员可以通过 /proc ⽂件系统，⼿动设置进程的 oom\_adj ，从⽽调整进程的 oom\_score。
 *  oom\_adj 的范围是 \[-17, 15\]，数值越⼤，表示进程越容易被 OOM 杀死；数值越⼩，表示进程越不容易被 OOM 杀死，其中 -17 表示禁⽌ OOM。

⽐如⽤下⾯的命令，你就可以把 sshd 进程的 oom\_adj 调⼩为 -16，这样， sshd 进程就不容易被 OOM 杀死。

echo -16 > /proc/$(pidof sshd)/oom_adj

当系统发现内存不足以分配新的内存请求时，就会尝试直接内存回收。这种情况下，如果回收完文件页和匿名页后，内存够用了，当然皆大欢喜，把回收回来的内存分配个进程就可以了。但是如果内存还是不足，OOM就要登场了。

OOM 发⽣时，你可以在 dmesg 中看到 Out of memory 的信息，从⽽知道是哪些进程被 OOM 杀死了。⽐如，你可以执⾏下⾯的命令，查询 OOM ⽇志：

$ dmesg | grep -i "Out of memory"
    Out of memory: Kill process 9329 (java) score 321 or sacrifice child

当然了，如果你不希望应⽤程序被 OOM 杀死，可以调整进程的 oom\_score\_adj，减⼩ OOM 分值，进⽽降低被杀死的概率。或者，你还可以开启内存的 overcommit，允许进程申请超过物理内存的虚拟内存（这⼉实际上假设的是，进程不会⽤光申请到的虚拟内存）。

> 问题：回收后的内存又到哪里去了？

内存回收后，会被重新放到未使用内存中。这样，新的进程就可以请求，使用它们

> 问题： OOM是按照虚拟内存还是实际内存来打分

OOM触发的实际基于虚拟内存。换句话说，进程在申请内存时，如果申请的虚拟内存加上服务器实际上已用的内存之和，比总的物理内存还大，就会触发OOM

> 问题：怎么评估应用程序的最小内存

*  要确定⼀个进程或者容器的最⼩内存，最简单的⽅法就是让它运⾏起来，再通过 ps 或者 smap ，查看它的内存使⽤情况。
 *  不过要注意，进程刚启动时，可能还没开始处理实际业务，⼀旦开始处理实际业务，就会占⽤更多内存。所以，要记得给内存留⼀定的余量。

# 如何查看内存的使用情况 #

> free 显示整个系统的内存使⽤情况：

# 注意不同版本的free输出可能会有所不同
    $ free
    total used free shared buff/cache available
    Mem: 8169348 263524 6875352 668 1030472 7611064
    Swap: 0 0 0

你可以看到，free 输出的是⼀个表格，其中的数值都默认以字节为单位。表格总共有两⾏六列，这两⾏分别是物理内存 Mem和交换分区 Swap 的使⽤情况，⽽六列中，每列数据的含义分别为：

*  第⼀列，total 是总内存⼤⼩；
 *  第⼆列，used 是已使⽤内存的⼤⼩，包含了共享内存；
 *  第三列，free 是未使⽤内存的⼤⼩；
 *  第四列，shared 是共享内存的⼤⼩；
 *  第五列，buff/cache 是缓存和缓冲区的⼤⼩；
 *  最后⼀列，available 是新进程可⽤内存的⼤⼩

这⾥尤其注意⼀下，最后⼀列的可⽤内存available 。available不仅包含未使⽤内存，还包括了可回收的缓存，所以⼀般会⽐未使用内存更大。不过，并不是所有缓都可以回收，因为有些缓存可能正在使用中。

> 如果想查看进程的内存使用情况，请用top或者ps

# 按下M切换到内存排序
    $ top
    ...
    KiB Mem : 8169348 total, 6871440 free, 267096 used, 1030812 buff/cache
    KiB Swap: 0 total, 0 free, 0 used. 7607492 avail Mem
    
    
    PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
    430 root 19 -1 122360 35588 23748 S 0.0 0.4 0:32.17 systemd-journal
    1075 root 20 0 771860 22744 11368 S 0.0 0.3 0:38.89 snapd
    1048 root 20 0 170904 17292 9488 S 0.0 0.2 0:00.24 networkd-dispat
    1 root 20 0 78020 9156 6644 S 0.0 0.1 0:22.92 systemd
    12376 azure 20 0 76632 7456 6420 S 0.0 0.1 0:00.01 systemd
    12374 root 20 0 107984 7312 6304 S 0.0 0.1 0:00.00 sshd

top 输出界⾯的顶端，也显示了系统整体的内存使⽤情况。我们接着看下⾯的内  
容，跟内存相关的⼏列数据，⽐如 VIRT、RES、SHR 以及 %MEM 等。

这些数据，包含了进程最重要的⼏个内存使⽤情况，我们挨个来看。

*  VIRT是进程虚拟内存你得大小，只要是进程申请过的内存，即使还没有真正分配物理内存，也会计算在内
 *  RES是常驻内存的大小，也就是进程实际使用物理内存的大小，但不包括swap和共享内存
 *  SHR是共享内存的大小，比如与其他进程共同使用的共享内存、加载到动态链接库以及程序的代码段等
 *  %MEM 是进程使⽤物理内存占系统总内存的百分⽐。

除了要认识这些基本信息，在查看 top 输出时，你还要注意两点。

*  第⼀，虚拟内存通常并不会全部分配物理内存。从上⾯的输出，你可以发现每个进程的虚拟内存都⽐常驻内存⼤得多。
 *  第⼆，共享内存 SHR 并不⼀定是共享的，⽐⽅说，程序的代码段、⾮共享的动态链接库，也都算在 SHR ⾥。当然，SHR 也包括了进程间真正共享的内存。所以在计算多个进程的内存使⽤时，不要把所有进程的 SHR 直接相加得出结果

# 注意 #

*  linux的内存跟windows的很不⼀样。**类linux的系统会尽量使⽤内存缓存东⻄，提供运⾏效率。所以linux/mac显示的free剩余内存通常很⼩，但实际上被缓存的cache可能很⼤，并不代表系统内存紧张！**
 *  以前物理机上还有swap交换分区，现在都是云服务器，基本没有了该分区。也不会遇到因为频繁使⽤交换分区导致性能下降的问题了。
 *  redis对内存⽐较敏感，曾经就因为配置项是默认值，在内存⽤完后，所有的set操作都直接返回错误，导致线上系统故障。（redis在备份时会新开⼀个进程，实际使⽤内存量会翻番。）后来会定期检查redis 的info memory 看内存使⽤情况。
 *  推荐博客：[⼿把⼿教你使⽤程序（C语⾔）来实际地去搞清楚虚拟内存分布][C]

# 总结 #

上面我们梳理了Linux内存的工作原理。**对普通进程来说，它能看到的实际是内核提供的虚拟内存，这些虚拟内存还需要通过页表，由系统映射为物理内存**

当进程通过malloc()申请内存后，内存并不会立即分配，而是在首次访问时，才通过缺页异常陷入内核中分配内存

由于进程的虚拟地址空间比物理内存大得多，Linux还通过了一系列的机制，来应该内存不足的问题，比如缓存的回收、交换分区swap以及OOM等

当你需要了解系统或者进程的内存使⽤情况时，可以⽤ free 和 top 、ps 等性能⼯具。它们都是分析性能问题时最常⽤的性能⼯具

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/802c0eed019b466a8d7f30f83d508060.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_16_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/fef28f7431544cc38e16ee1944bb444e.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/2b8c1cda71394690b8900a81fa39fe01.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_9_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/7beec1207353474993e5e124a3546e5d.png
[C]: https://blog.holbertonschool.com/hack-the-virtual-memory-c-strings-proc/