首页 / LINUX / linux下的缓存机制buffer、cache、swap

linux下的缓存机制buffer、cache、swap

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了linux下的缓存机制buffer、cache、swap，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含16703字，纯文字阅读大概需要24分钟。

内容图文

一、缓存机制介绍

在Linux系统中，为了提高文件系统性能，内核利用一部分物理内存分配出缓冲区，用于缓存系统操作和数据文件，当内核收到读写的请求时，内核先去缓存区找是否有请求的数据，有就直接返回，如果没有则通过驱动程序直接操作磁盘。
缓存机制优点：减少系统调用次数，降低CPU上下文切换和磁盘访问频率。
CPU上下文切换：CPU给每个进程一定的服务时间，当时间片用完后，内核从正在运行的进程中收回处理器，同时把进程当前运行状态保存下来，然后加载下一个任务，这个过程叫做上下文切换。实质上就是被终止运行进程与待运行进程的进程切换。

Swap用途：Swap意思是交换分区，通常我们说的虚拟内存，是从硬盘中划分出的一个分区。当物理内存不够用的时候，内核就会释放缓存区（buffers/cache）里一些长时间不用的程序，然后将这些程序临时放到Swap中，也就是说如果物理内存和缓存区内存不够用的时候，才会用到Swap。
swap清理：swapoff -a && swapon -a
注意：这样清理有个前提条件，空闲的内存必须比已经使用的swap空间大

二、查看缓存区及内存使用情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
对于cpu负载的理解，首先需要搞清楚下面几个问题：
   
1）系统load高不一定是性能有问题。
因为Load高也许是因为在进行cpu密集型的计算
   
2）系统Load高不一定是CPU能力问题或数量不够。
因为Load高只是代表需要运行的队列累计过多了。但队列中的任务实际可能是耗Cpu的，也可能是耗i /0 或者其他因素的。
   
3）系统长期Load高，解决办法不是一味地首先增加CPU
因为Load只是表象，不是实质。增加CPU个别情况下会临时看到Load下降，但治标不治本。
   
4）在Load average 高的情况下需要鉴别系统瓶颈到底是CPU不足，还是io不够快造成或是内存不足造成的。
   
===============================================================================================================
要想获得服务器的CPU负载情况，有下面几种命令：
1）w命令
[root@localhost ~] # w
  12:12:41 up 167 days, 20:46,  2 users ,  load average: 0.00, 0.01, 0.05
USER     TTY      FROM             LOGIN@   IDLE   JCPU   PCPU WHAT
root     pts /0    192.168.1.5      10:01    1.00s  0.11s  0.00s w
root     pts /2    192.168.1.5      10:19    1:47m  0.04s  0.04s -bash
    
2）uptime命令（一般首先会根据最后那个15分钟的load负载为准）
[root@localhost ~] # uptime
  12:12:55 up 167 days, 20:46,  2 users ,  load average: 0.00, 0.01, 0.05
    
3） top 命令
[root@localhost ~] # top
top - 12:13:22 up 167 days, 20:47,  2 users ,  load average: 0.00, 0.01, 0.05
Tasks: 272 total,   1 running, 271 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.0 us,  0.1 sy,  0.0 ni, 99.9 id ,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
KiB Mem : 65759080 total, 58842616 free ,   547908 used,  6368556 buff /cache
KiB Swap:  2097148 total,  2097148 free ,        0 used. 64264884 avail Mem
................
 
对于第一行的解释：
12:13:22：表示当前系统时间
167 days, 20:47：表示系统已经运行了167天20小时47分钟（在这期间没有重启过）
2 users — 当前有2个用户登录系统
load average: 0.00, 0.01, 0.05：表示load average后面的三个数分别是1分钟、5分钟、15分钟的负载情况
 
这里需要注意：
load average数据是每隔5秒钟检查一次活跃的进程数，然后按特定算法计算出的数值。
如果这个数除以逻辑CPU的数量，结果高于5的时候就表明系统在超负荷运转了！！！！！
 
对上面第三行cpu的状态的解释：
us（user cpu time ）：用户态使用的cpu时间比。该值较高时，说明用户进程消耗的 CPU 时间比较多，比如，如果该值长期超过 50%，则需要对程序算法或代码等进行优化。
sy（system cpu time ）：系统态使用的cpu时间比。
ni（user nice cpu time ）：用做 nice 加权的进程分配的用户态cpu时间比
id （idle cpu time ）：空闲的cpu时间比。如果该值持续为0，同时sy是us的两倍，则通常说明系统则面临着 CPU 资源的短缺。
wa（io wait cpu time ）：cpu等待磁盘写入完成时间。该值较高时，说明IO等待比较严重，这可能磁盘大量作随机访问造成的，也可能是磁盘性能出现了瓶颈。
hi（hardware irq）：硬中断消耗时间
si（software irq）：软中断消耗时间
st（steal time ）：虚拟机偷取时间
   
以上解释的这些参数的值加起来是100%。
   
4）vmstat
[root@localhost ~] # vmstat
procs -----------memory---------------------swap-------io---------system--------cpu-----
r  b      swpd   free    buff   cache    si   so    bi    bo     in   cs     us sy idwa st
3  0      0      1639792 724280 4854236  0    0     4     34     4    0      19 45 35  0  0
   
解释说明：
-----------------------------
procs部分的解释
r 列表示运行和等待cpu时间片的进程数，如果长期大于1，说明cpu不足，需要增加cpu。
b 列表示在等待资源的进程数，比如正在等待I /O 、或者内存交换等。
-----------------------------
cpu部分的解释
us 列显示了用户方式下所花费 CPU 时间的百分比。us的值比较高时，说明用户进程消耗的cpu时间多，但是如果长期大于50%，需要考虑优化用户的程序。
sy 列显示了内核进程所花费的cpu时间的百分比。这里us + sy的参考值为80%，如果us+sy 大于 80%说明可能存在CPU不足。
wa 列显示了IO等待所占用的CPU时间的百分比。这里wa的参考值为30%，如果wa超过30%，说明IO等待严重，这可能是磁盘大量随机访问造成的，也可能磁盘或者
    磁盘访问控制器的带宽瓶颈造成的(主要是块操作)。
id 列显示了cpu处在空闲状态的时间百分比
-----------------------------
system部分的解释
in 列表示在某一时间间隔中观测到的每秒设备中断数。
cs列表示每秒产生的上下文切换次数，如当 cs 比磁盘 I /O 和网络信息包速率高得多，都应进行进一步调查。
-----------------------------
memory部分的解释
swpd 切换到内存交换区的内存数量(k表示)。如果swpd的值不为0，或者比较大，比如超过了100m，只要si、so的值长期为0，系统性能还是正常
free 当前的空闲页面列表中内存数量(k表示)
buff 作为buffer cache的内存数量，一般对块设备的读写才需要缓冲。
cache: 作为page cache的内存数量，一般作为文件系统的cache，如果cache较大，说明用到cache的文件较多，如果此时IO中bi比较小，说明文件系统效率比较好。
-----------------------------
swap部分的解释
si 由内存进入内存交换区数量。
so由内存交换区进入内存数量。
-----------------------------
IO部分的解释
bi 从块设备读入数据的总量（读磁盘）（每秒kb）。
bo 块设备写入数据的总量（写磁盘）（每秒kb）
   
   
5）也可以使用dstat命令查看cpu信息
[root@localhost ~] # dstat
----total-cpu-usage---- -dsk /total- -net /total- ---paging-- ---system--
usr sys idl wai hiq siq| read  writ| recv  send|  in   out | int   csw
  19  45  35   0   0   0|  30k  265k|   0     0 |   0     0 |9025    12k
   9  18  73   0   0   0|   0   144k|2578k   65k|   0     0 |3956  4343
   
6）可以使用iostat查看IO负载
[root@localhost ~] # iostat 1 1
Linux 2.6.32-696.16.1.el6.x86_64 ( nc -ftp01.kevin.cn)    2017年12月29日     _x86_64_    (4 CPU)
   
avg-cpu:  %user   % nice %system %iowait  %steal   %idle
           19.32    0.00   45.44    0.06    0.26   34.93
   
Device:            tps   Blk_read /s   Blk_wrtn/s   Blk_read   Blk_wrtn
xvda             14.17        29.94       265.17   63120486  558975100
  
解释说明：
avg-cpu: 总体cpu使用情况统计信息，对于多核cpu，这里为所有cpu的平均值
%user: 在用户级别运行所使用的CPU的百分比.
% nice : nice 操作所使用的CPU的百分比.
%sys: 在系统级别(kernel)运行所使用CPU的百分比.
%iowait: CPU等待硬件I /O 时,所占用CPU百分比.
%idle: CPU空闲时间的百分比.
  
Device段:各磁盘设备的IO统计信息
tps: 每秒钟发送到的I /O 请求数.
Blk_read /s : 每秒读取的block数.
Blk_wrtn /s : 每秒写入的block数.
Blk_read:   读入的block总数.
Blk_wrtn:  写入的block总数.
  
[root@localhost ~] # iostat -x -k -d 1
Linux 2.6.32-696.el6.x86_64 (centos6-vm02)  01 /04/2018  _x86_64_    (4 CPU)
  
Device:         rrqm /s   wrqm/s     r/s     w/s    rkB/s    wkB/savgrq-sz avgqu-sz   await r_await w_await  svctm  %util
scd0              0.00     0.00    0.00    0.00     0.00     0.00     8.00     0.00    0.36    0.36    0.00   0.36   0.00
vda               0.01     0.13    0.04    0.13     0.60     0.89    18.12     0.00    2.78    0.19    3.53   2.55   0.04
dm-0              0.00     0.00    0.04    0.22     0.58     0.88    11.25     0.00    3.27    0.25    3.82   1.61   0.04
dm-1              0.00     0.00    0.00    0.00     0.00     0.00     8.00     0.00    0.13    0.13    0.00   0.04   0.00
dm-2              0.00     0.00    0.00    0.00     0.00     0.00     7.91     0.00    0.19    0.10    5.00   0.16   0.00
  
解释说明：
rrqm /s : 每秒对该设备的读请求被合并次数，文件系统会对读取同块(block)的请求进行合并
wrqm /s : 每秒对该设备的写请求被合并次数
r /s : 每秒完成的读次数
w /s : 每秒完成的写次数
rkB /s : 每秒读数据量(kB为单位)
wkB /s : 每秒写数据量(kB为单位)
avgrq-sz:平均每次IO操作的数据量(扇区数为单位)
avgqu-sz: 平均等待处理的IO请求队列长度
await: 平均每次IO请求等待时间(包括等待时间和处理时间，毫秒为单位)
svctm: 平均每次IO请求的处理时间(毫秒为单位)
%util: 采用周期内用于IO操作的时间比率，即IO队列非空的时间比率
  
如果 %util 接近 100%，说明产生的I /O 请求太多，I /O 系统已经满负荷，该磁盘可能存在瓶颈。
idle小于70% IO压力就较大了,一般读取速度有较多的wait。
同时可以结合vmstat 查看查看b参数(等待资源的进程数)和wa参数(IO等待所占用的CPU时间的百分比,高过30%时IO压力高)

三、buffers和cached解释

缓存（cached）是把读取过的数据保存起来，重新读取时若命中（找到需要的数据）就不要去读硬盘了，若没有命中就读硬盘。其中的数据会根据读取频率进行组织，把最频繁读取的内容放在最容易找到的位置，把不再读的内容不断往后排，直至从中删除。

缓冲（buffers）是根据磁盘的读写设计的，把分散的写操作集中进行，减少磁盘碎片和硬盘的反复寻道，从而提高系统性能。linux有一个守护进程定期清空缓冲内容（即写入磁盘），也可以通过sync命令手动清空缓冲。举个例子吧：我这里有一个ext2的U盘，我往里面cp一个3M的MP3，但U盘的灯没有跳动，过了一会儿（或者手动输入sync）U盘的灯就跳动起来了。卸载设备时会清空缓冲，所以有些时候卸载一个设备时要等上几秒钟。

修改/etc/sysctl.conf中的vm.swappiness右边的数字可以在下次开机时调节swap使用策略。该数字范围是0～100，数字越大越倾向于使用swap。默认为60，可以改一下试试。–两者都是RAM中的数据。

两者都是RAM中的数据，简单来说，buffer是即将要被写入磁盘的，而cache是被从磁盘中读出来的。
buffer是由各种进程分配的，被用在如输入队列等方面。一个简单的例子如某个进程要求有多个字段读入，在所有字段被读入完整之前，进程把先前读入的字段放在buffer中保存。
cache经常被用在磁盘的I/O请求上，如果有多个进程都要访问某个文件，于是该文件便被做成cache以方便下次被访问，这样可提高系统性能。

Cache：缓冲区，高速缓存，是位于CPU与主内存间的一种容量较小但速度很高的存储器。由于CPU的速度远高于主内存，CPU直接从内存中存取数据要等待一定时间周期，Cache中保存着CPU刚用过或循环使用的一部分数据，当CPU再次使用该部分数据时可从Cache中直接调用,这样就减少了CPU的等待时间,提高了系统的效率。Cache又分为一级Cache(L1 Cache)和二级Cache(L2 Cache)，L1 Cache集成在CPU内部，L2 Cache早期一般是焊在主板上,现在也都集成在CPU内部，常见的容量有256KB或512KB L2 Cache。它是根据程序的局部性原理而设计的，就是cpu执行的指令和访问的数据往往在集中的某一块，所以把这块内容放入cache后，cpu就不用在访问内存了，这就提高了访问速度。当然若cache中没有cpu所需要的内容，还是要访问内存的。从内存读取与磁盘读取角度考虑，cache可以理解为操作系统为了更高的读取效率，更多的使用内存来缓存可能被再次访问的数据。

Cache并不是缓存文件的，而是缓存块的(块是I/O读写最小的单元)；Cache一般会用在I/O请求上，如果多个进程要访问某个文件，可以把此文件读入Cache中，这样下一个进程获取CPU控制权并访问此文件直接从Cache读取，提高系统性能。

Buffer：缓冲区，一个用于存储速度不同步的设备或优先级不同的设备之间传输数据的区域。通过buffer可以减少进程间通信需要等待的时间，当存储速度快的设备与存储速度慢的设备进行通信时，存储慢的数据先把数据存放到buffer，达到一定程度存储快的设备再读取buffer的数据，在此期间存储快的设备CPU可以干其他的事情。

Buffer：一般是用在写入磁盘的，例如：某个进程要求多个字段被读入，当所有要求的字段被读入之前已经读入的字段会先放到buffer中。Buffer是根据磁盘的读写设计的，把分散的写操作集中进行，减少磁盘碎片和硬盘的反复寻道，从而提高系统性能。linux有一个守护进程定期清空缓冲内容（即写入磁盘），也可以通过sync命令手动清空缓冲。

cache是高速缓存，用于CPU和内存之间的缓冲；
buffer是I/O缓存，用于内存和硬盘的缓冲；

cache最初用于cpu cache，主要原因是cpu 与memory，由于cpu快，memory跟不上,且有些值使用次数多，所以放入cache中，主要目的是，重复使用，并且一级\二级物理cache速度快，
buffer主要用于disk与 memory，主要是保护硬盘或减少网络传输的次数（内存数据表现dataSet）．当然也可以提高速度（不会立即写入硬盘或直接从硬盘中读出的数据马上显示），重复使用，最初最主要的目的是保护disk,

Free中的buffer和cache：（它们都是占用内存）：
buffer : 作为buffer cache的内存，是块设备的读写缓冲区
cache: 作为page cache的内存, 文件系统的cache

如果 cache 的值很大，说明cache住的文件数很多。如果频繁访问到的文件都能被cache住，那么磁盘的读IO bi会非常小。

========================================================
下面通过一些简单通俗的例子来说明下Cache和Buffer缓存之间的区别：

1）Cache缓存

假设某地发生了自然灾害（比如地震），居民缺衣少食，于是派救火车去给若干个居民点送水。救火车到达第一个居民点，开闸放水，老百姓就拿着盆盆罐罐来接水。假如说救火车在一个居民点停留100分钟放完了水，然后重新储水花半个小时，再开往下一个居民点。这样一个白天来来来回回的，也就是4-5个居民点。

但我们想想，救火车是何等存在，如果把水龙头完全打开，其强大的水压能轻易冲上10层楼以上， 10分钟就可以把水全部放完。但因为居民是拿盆罐接水，100%打开水龙头那就是给人洗澡了，所以只能打开一小部分（比如10%的流量）。但这样就降低了放水的效率（只有原来的10%了），10分钟变100分钟。

那么，我们是否能改进这个放水的过程，让救火车以最高效率放完水、尽快赶往下一个居民点呢？
方法就是：在居民点建蓄水池。
救火车把水放到蓄水池里，因为是以100%的效率放水，10分钟结束然后走人。居民再从蓄水池里一点一点的接水。

我们分析一下这个例子，就可以知道Cache的含义了。
救火车要给居民送水，居民要从救火车接水，就是说居民和救火车之间有交互，有联系。
但救火车是"高速设备"，居民是"低速设备"，低速的居民跟不上高速的救火车，所以救火车被迫降低了放水速度以适应居民。
为了避免这种情况，在救火车和居民之间多了一层"蓄水池（也就是Cache）"，它一方面以100%的高效和救火车打交道，另一方面以10%的低效和居民打交道，这就解放了救火车，让其以最高的效率运行，而不被低速的居民拖后腿，于是救火车只需要在一个居民点停留10分钟就可以了。
所以说，蓄水池是"活雷锋"，把高效留给别人，把低效留给自己。把10分钟留给救火车，把100分钟留给自己。

从以上例子可以看出，所谓Cache，就是"为了弥补高速设备和低速设备之间的矛盾"而设立的一个中间层。因为在现实里经常出现高速设备要和低速设备打交道，结果被低速设备拖后腿的情况。Cache的存在是为了解决什么问题？速度太慢了，要加快速度！

以PC为例。CPU速度很快，但CPU执行的指令是从内存取出的，计算的结果也要写回内存，但内存的响应速度跟不上CPU。CPU跟内存说：你把某某地址的指令发给我。内存听到了，但因为速度慢，迟迟不见指令返回，这段时间，CPU只能无所事事的等待了。这样一来，再快的CPU也发挥不了效率。
怎么办呢？在CPU和内存之间加一块"蓄水池"，也就是Cache（片上缓存），这个Cache速度比内存快，从Cache取指令不需要等待。当CPU要读内存的指令的时候先读Cache再读内存，但一开始Cache是空着的，只能从内存取，这时候的确是很慢，CPU需要等待。但从内存取回的不仅仅是CPU所需要的指令，还有其它的、当前不需要的指令，然后把这些指令存在Cache里备用。CPU再取指令的时候还是先读Cache，看看里面有没有所需指令，如果碰巧有就直接从Cache取，不用等待即可返回（命中），这就解放了CPU，提高了效率。（当然不会是100%命中，因为Cache的容量比内存小）

2）Buffer缓存

比如说吐鲁番的葡萄熟了，要用大卡车装葡萄运出去卖果园的姑娘采摘葡萄，当然不是前手把葡萄摘下来,后手就放到卡车上，而是需要一个中间过程"箩筐"：摘葡萄→放到箩筐里→把箩筐里的葡萄倒入卡车。也就是说，虽然最终目的是"把葡萄倒入卡车"，但中间必须要经过"箩筐"的转手，这里的箩筐就是Buffer。是"暂时存放物品的空间"。
注意2个关键词：暂时，空间
再换句话说，为了完成最终目标：把葡萄放入卡车的空间，需要暂时把葡萄放入箩筐的空间。

以BT为例，BT下载需要长时间的挂机，电脑就有可能24小时连轴转，但BT下载的数据是碎片化的，体现在硬盘写入上也是碎片化的，因为硬盘是机械寻址器件，这种碎片化的写入会造成硬盘长时间高负荷的机械运动，造成硬盘过早老化损坏，当年有大量的硬盘因为BT下载而损坏。于是新出的BT软件在内存里开辟了Buffer，数据暂时写入Buffer，攒到一定的大小（比如512M）再一次性写入硬盘，这种"化零为整"的写入方式大大降低了硬盘的负荷。这就是：为了完成最终目标：把数据写入硬盘空间，需要暂时写入Buffer的空间。

3）二者之间的区别总结

Cache和Buffer的相同点：都是2个层面之间的中间层，都是内存。
Cache和Buffer的不同点：Cache解决的是时间问题，Buffer解决的是空间问题。
为了提高速度，引入了Cache这个中间层。
为了给信息找到一个暂存空间，引入了Buffer这个中间层。
为了解决2个不同维度的问题（时间、空间），恰巧取了同一种解决方法：加入一个中间层，先把数据写到中间层上，然后再写入目标。
这个中间层就是内存“RAM”，既然是存储器就有2个参数：写入的速度有多块（速度），能装多少东西（容量）
Cache利用的是RAM提供的高读写速度，Buffer利用的是RAM提供的存储容量（空间）。

简言之：
1. Buffer（缓冲区）是系统两端处理速度平衡（从长时间尺度上看）时使用的。它的引入是为了减小短期内突发I/O的影响，起到流量整形的作用。比如生产者——消费者问题，他们产生和消耗资源的速度大体接近，加一个buffer可以抵消掉资源刚产生/消耗时的突然变化。
2. Cache（缓存）则是系统两端处理速度不匹配时的一种折衷策略。因为CPU和memory之间的速度差异越来越大，所以人们充分利用数据的局部性（locality）特征，通过使用存储系统分级（memory hierarchy）的策略来减小这种差异带来的影响。
3. 假定以后存储器访问变得跟CPU做计算一样快，cache就可以消失，但是buffer依然存在。比如从网络上下载东西，瞬时速率可能会有较大变化，但从长期来看却是稳定的，这样就能通过引入一个buffer使得OS接收数据的速率更稳定，进一步减少对磁盘的伤害。

四、手动清理缓存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
释放缓存区内存的方法
1）清理pagecache（页面缓存）
[root@backup ~] # echo 1 > /proc/sys/vm/drop_caches     或者 # sysctl -w vm.drop_caches=1
 
2）清理dentries（目录缓存）和inodes
[root@backup ~] # echo 2 > /proc/sys/vm/drop_caches     或者 # sysctl -w vm.drop_caches=2
 
3）清理pagecache、dentries和inodes
[root@backup ~] # echo 3 > /proc/sys/vm/drop_caches     或者 # sysctl -w vm.drop_caches=3
上面三种方式都是临时释放缓存的方法，要想永久释放缓存，需要在 /etc/sysctl .conf文件中配置：vm.drop_caches=1 /2/3 ，然后sysctl -p生效即可！
 
另外，可以使用 sync 命令来清理文件系统缓存，还会清理僵尸(zombie)对象和它们占用的内存
[root@backup ~] # sync
 
 
温馨提示：
上面操作在大多数情况下都不会对系统造成伤害，只会有助于释放不用的内存。
但是如果在执行这些操作时正在写数据，那么实际上在数据到达磁盘之前就将它从文件缓存中清除掉了，这可能会造成很不好的影响。
 
那么如果避免这种事情发生呢？
因此，这里不得不提一下 /proc/sys/vm/vfs_cache_pressure 这个文件，告诉内核，当清理inoe /dentry 缓存时应该用什么样的优先级。
[root@backup ~] # cat /proc/sys/vm/vfs_cache_pressure
100
 
vfs_cache_pressure=100    这个是默认值，内核会尝试重新声明dentries和inodes，并采用一种相对于页面缓存和交换缓存比较 "合理" 的比例。
 
减少vfs_cache_pressure的值，会导致内核倾向于保留dentry和inode缓存。
增加vfs_cache_pressure的值，（即超过100时），则会导致内核倾向于重新声明dentries和inodes
  
总之，vfs_cache_pressure的值：
小于100的值不会导致缓存的大量减少
超过100的值则会告诉内核你希望以高优先级来清理缓存。
  
其实无论vfs_cache_pressure的值采用什么值，内核清理缓存的速度都是比较低的。
如果将此值设置为10000，系统将会将缓存减少到一个合理的水平。
======================================================
 
这里顺便说下自己遇到的一个内存问题：
IDC机房有一台专门的备份服务器，每天凌晨执行多个备份脚本。某天早上突然发现收到很多条zabbix监控报警信息：这台备份服务器的内存使用了已超过80%！
于是，赶紧登陆这台备份服务器，使用 free 命令查看内存使用情况：
[root@backup ~] # free -m
              total       used       free     shared    buffers     cached
Mem:         64181      48585      15596          3          2         18
-/+ buffers /cache :      48564      15617
Swap:        32767          0      3276
 
确实发现内存使用率已超过80%！但是使用 "top" 命令查看，发现此时并没有什么进程在占用内存，并且本机是备份服务器，只有晚上执行备份脚本，
其他时间都没有服务进程在跑！于是尝试手动释放内存：
[root@backup ~] # echo 1 > /proc/sys/vm/drop_caches
[root@backup ~] # echo 2 > /proc/sys/vm/drop_caches
[root@backup ~] # echo 3 > /proc/sys/vm/drop_caches
[root@backup ~] # sync
 
发现在执行了上面第三条命令后，内存才真正被释放出来了，其他命令都没有起到效果。

五、"Cannot allocate memory"问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
启动服务器上的tomcat服务，发现启动后服务没有起来！查看日志发现 "Cannot allocate memory" ,内存不够了！
 
[root@tomcat ~] # /opt/tomcat_b/tomcat_7777/startup.sh start
 
[root@tomcat ~] # ps -ef|grep tomcat_7777
bxapp      2165   1821  0 11:50 pts /5    00:00:00 greptomcat_7777
[root@tomcat ~] #
 
[root@tomcat ~] # cat catalina.out
Java HotSpot(TM) 64-Bit Server VM warning: INFO: os::commit_memory(0x00000000a0000000, 1610612736, 0) failed; error= ‘Cannot allocate memory‘ (errno=12)
#
# There is insufficient memory for the Java Runtime Environment to continue.
# Native memory allocation (mmap) failed to map 1610612736 bytes for committing reserved memory.
# An error report file with more information is saved as:
# /opt/tomcat_b/pay-service/hs_err_pid125225.log
Java HotSpot(TM) 64-Bit Server VM warning: INFO: os::commit_memory(0x00000000a0000000, 1610612736, 0) failed; error= ‘Cannot allocate memory‘ (errno=12)
#
# There is insufficient memory for the Java Runtime Environment to continue.
# Native memory allocation (mmap) failed to map 1610612736 bytes for committing reserved memory.
# An error report file with more information is saved as:
# /opt/tomcat_b/tomcat_7777/bin/hs_err_pid125352.log
 
解决 "Cannot allocate memory" 问题的方法（内存不够，没法分配内存）：
1）调整系统的内存参数
# echo 1 > /proc/sys/vm/overcommit_memory   # 临时修改
# vim /etc/sysctl.conf                      # 永久修改
vm.overcommit_memory=1
# sysctl -p
 
2) 调整系统的最大进程数目
查看系统允许的当前最大进程数
主要是查看pid_max指标的，pid_max是Linux内核用来限制进程数的一个最大指标。
换言之，即最大允许进程就这么多，超过了这个设定值，服务器就挂了（ "ps -eLf | wc -l" 查看本机器的进程数）
# sysctl kernel.pid_max    # centos7系统执行"systemctl kernel.pid_max"命令
kernel.pid_max = 32768
或者
# cat /proc/sys/kernel/pid_max
32768
 
一般出现 - bash : fork: Cannot allocate memory 本机的进程数应该接近或等于pid_max指标值的。
# echo 65536 > /proc/sys/kernel/pid_max                   # 临时修改
# echo "kernel.pid_max=65536" >> /etc/sysctl.conf         # 永久修改
# sysctl -p 
kernel.pid_max = 65536
 
3）调整项目部署的tomcat的jvm内存参数
在setenv.sh或catalina.sh文件里重新调整内存，这种情况是设置的过大，包括-Xms2048M、-Xmx2048M、-Xmn512M、-Xss1024K、NewSize=256M、-XX:MaxNewSize=512M 这样的值，
物理内存不够，把配置调小即可。
 
4）设置swap或者调大swap内存太小。有时系统默认没有开启虚拟内存，就会经常遇到软件内存不足，运行崩溃的情况。
有时在云服务器上（比如阿里云），为了减少购买昂贵的内存资源，可以暂时使用虚拟内存代替（根据运行的程序需求，性能会降低一些）。
swap虚拟内存说明和运维注意点：
https: //www .cnblogs.com /kevingrace/p/5991604 .html
https: //www .cnblogs.com /kevingrace/p/5570197 .html
 
1. 查看内存使用情况，发现swap虚拟内存空间竟然为0
# free -m 
2. 建虚拟内存磁盘卷。做法如下：
# dd if=/dev/zero of=/opt/swap bs=1024 count=2048000
# mkswap /opt/swap
# swapon /opt/swap
 
再次查看内容，发现swap虚拟内存就有了
# free -m
 
3. 如果想取消文件虚拟内存，即删除swap，做法如下：（当然根据系统配置，也可以保留swap，以后继续用）。
# swapoff /opt/swap
# rm /opt/swap
 
4. swap开机挂载
# vim /etc/fstab
/opt/swap  swap                    swap    defaults        0 0
 
上面挂载参数分别为：
设备文件或伪文件系统   挂载点  文件系统类型  挂载选项 备份频率 开机自检次序
 
===========================================================================
这里顺便说下，阿里云服务器默认没有开启虚拟内存，经常遇到软件内存不足，运行崩溃的情况。
阿里云虚拟机上创建swap虚拟内存磁盘卷的做法如下：
 
大概count=2024288，2G左右，可以视磁盘大小和需求创建。
 
1. 默认存放在 /swap/swapadd ，可以是自己的任何目录。
阿里云服务器默认没有swap，需要自己创建。
# mkdir /swap
# dd if=/dev/zero of=/swap/swapadd bs=1024 count=2024288
 
2. 将磁盘卷转为虚拟内存卷
# mkswap /swap/swapadd
 
3. 启用虚拟内存服务
# swapon /swap/swapadd
 
4. 这时再查看内存，发现已经开启了swap虚拟内存。即多出来2G左右的swap空间。
# free -m
 
5. 如果想再关闭虚拟内存服务，执行下面命令即可：
# swapoff -v /swap/swapadd
 
6. 移动虚拟内存空间
如果当前的虚存所在的磁盘空间不够，可以首先关闭虚存服务，将其移动到别的磁盘，再启用即可。
# swapoff -v /swap/swapadd
# mv /swap/swapadd /mnt/swap
# swapon /swap/swapadd
 
5）极端情况：没有足够内存分配，导致机器操作一直处于卡着的情况！
在linux终端里执行命令时，发现 "-bash: fork: Cannot allocate memory:" 问题即进程数满了！！
出现这种情况，主要是因为进程跑满了，memory被消耗光了，无法再为其他操作分配内存，包括执行一般操作命令和SSH连接分配内存！
除了上面四种处理方式外，还有一种比较粗暴的的方法，就是重启服务器，注意不是重启tomcat！
# init 6  
如果执行 "init 6" 重启机器不行，就使用 "reboot" 或者 "init 0" 强制重启(可能需要多敲几次)　　　　
 
----------------------------------------------------------------转自 https://www.cnblogs.com/kevingrace/p/5991604.html

原文：https://www.cnblogs.com/tudachui/p/11970595.html

内容总结

以上是互联网集市为您收集整理的linux下的缓存机制buffer、cache、swap全部内容，希望文章能够帮你解决linux下的缓存机制buffer、cache、swap所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1315558.html

来源：【匿名】