内存使用量

    执行 free 命令便可查看 内存使用量 ：

    命令展示了 物理内存 以及交换内存使用量，指标说明见下节。

    Linux 内核负责统计内存使用量并暴露在 proc 伪文件系统中，路径是 /proc/meminfo 。一般而言，需要重点关注的指标如下：

    total 表示 物理内存总量 ，单位为 字节 ，对应 /proc/meminfo 的 MemTotal 字段。

    free

    free 表示 空闲内存量 ，单位为 字节 ， 对应 /proc/meminfo 的 MemFree 字段。

    buffers

    buffers 表示 内核缓冲区 ，单位为 字节 ，对应 /proc/meminfo 的 Buffers 字段。

    cached 表示 文件缓冲页 ，单位为 字节 ，对应 /proc/meminfo 的 Cached 字段。

    slab

    slab 表示 内核slab数据结构 ，单位为 字节 ，对应 /proc/meminfo 的 Slab 字段。

    cache

    [cache = cached + slab]

    g_free 表示 广义空闲内存 ( generalized free )，单位为 字节 ，计算方式如下：

    [g_free = free + buffers + cache]

    buffers 和 cache 是系统为了提升性能而使用的缓存，内存紧张时可随时回收另做它用。因此，这部分内存在某种意义上可以认为是空闲的，这就是 广义空闲内存 的由来。在某些场景， g_free 比 free 更有参考价值。

    used

    used 表示 已用内存 ，单位为 字节 ，计算方式如下：

    [used = total - g_free = total - free - buffers - cache]

    active

    active 表示 活跃内存 ，单位为 字节 ，对应 /proc/meminfo 的 Active 字段。

    活跃内存 是指最近经常访问的内存，通常不会被重新分配，除非非常必要。

    非活跃内存 是指最近较少访问的内存，需要新分配内存时，这部分优先选择。

    available

    available 表示 可用内存 ，单位为 字节 ，对应 /proc/meminfo 的 MemAvailable 字段。

    可用内存 指的是可用于启动一个新应用进程的内存，该指标是内核提供的一个估计值。它同样结合 free 以及 cache 两部分内存，但是考虑到 cache 因使用而不能释放的情况。因此，可以认为：

    [free \le available \le g_free]

    数据采集非常简单，读取 /proc/meminfo 文件相关字段即可：

    memory_usage.py

    3. UNIT_MAPPING = {
    4.     'kB': 1024,
    5.     'KB': 1024,
    6. }
    9. def parse_value(value):
    10.     # default, no unit
    11.     unit = ''
    13.     # split value string
    14.     if len(parts) == 2:
    15.         number, unit = parts
    16.     else:
    17.         number, = parts
    19.     return int(number.strip()) * UNIT_MAPPING.get(unit.strip(), -1)
    22. def sample_memory_usage():
    24.     with open('/proc/meminfo') as f:
    25.         # open all lines
    26.         lines = f.readlines()
    28.         # split every line to a pair by :
    29.         pairs = [
    30.             line.strip().split(':', 1)
    31.             for line in lines
    32.         ]
    34.         # data dict
    35.         datas = {
    36.             name.strip(): parse_value(value)
    37.             for name, value in pairs
    38.         }
    40.         # calculate
    41.         total = datas['MemTotal']
    42.         buffers = datas['Buffers']
    43.         cached = datas['Cached']
    44.         slab = datas['Slab']
    46.         g_free = free + buffers + cache
    47.         used = total - g_free
    48.         active = datas['Active']
    49.         inactive = datas['Inactive']
    50.         available = datas['MemAvailable']
    52.         return {
    53.             'total': total,
    54.             'free': free,
    55.             'buffers': buffers,
    56.             'cached': cached,
    57.             'slab': slab,
    58.             'cache': cache,
    59.             'g_free': g_free,
    60.             'used': used,
    61.             'active': active,
    62.             'inactive': inactive,
    63.             'available': available,
    64.         }
    66. if __name__ == '__main__':
    67.     usage = sample_memory_usage()

    订阅更新，获取更多学习资料，请关注我们的 ：