blocks|key|262771|text|"Buffers“表示RAM中有多少部分专用于缓存磁盘块。"Cached“类似于"Buffers"，只不过这一次它会从文件读取中缓存页面。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|262772|引用自：|262773|262774|https://web.archive.org/web/20110207101856/http://www.linuxforums.org/articles/using-top-more-efficiently_89.html|unordered-list-item|offset|length|262775|262776|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|0|35|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|F]]]]

"Buffers" represent how much portion of RAM is dedicated to cache disk blocks. "Cached" is similar like "Buffers", only this time it caches pages from file reading.

quote from: 

<ul>
<li><a href="https://web.archive.org/web/20110207101856/http://www.linuxforums.org/articles/using-top-more-efficiently_89.html" rel="noreferrer">https://web.archive.org/web/20110207101856/http://www.linuxforums.org/articles/using-top-more-efficiently_89.html</a></li>
</ul>

blocks|key|3172886|text|Buffer是一个内存区域，用于在数据从一个位置移动到另一个位置时临时存储数据。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3172887|缓存是一个临时存储区域，用于存储频繁访问的数据，以便快速访问。一旦数据存储在缓存中，将来的使用可以通过访问缓存的副本来完成，而不是重新获取原始数据，因此平均访问时间更短。|3172888|注意:缓冲区和缓存也可以在磁盘上分配|3172889|entityMap^0|0|6|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

Buffer is an area of memory used to temporarily store data while it's being moved from one place to another.
Cache is a temporary storage area used to store frequently accessed data for rapid access. Once the data is stored in the cache, future use can be done by accessing the cached copy rather than re-fetching the original data, so that the average access time is shorter.
Note: buffer and cache can be allocated on disk as well

blocks|key|3172906|text|缓冲区和缓存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3172907|缓冲区是尚未“写入”到磁盘的东西。|3172908|缓存是从磁盘中“读取”并存储以供以后使用的东西。|3172909|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

buffer and cache. 

A buffer is something that has yet to be "written" to disk. 

A cache is something that has been "read" from the disk and stored for later use.

blocks|key|2959062|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2959063|缓冲区与特定的块设备相关联，涵盖文件系统元数据的缓存以及跟踪正在进行的页面。缓存仅包含驻留的文件数据。也就是说，缓冲区记住目录中的内容，文件权限是什么，并跟踪特定块设备正在从哪些内存中写入或读取哪些内存。缓存只包含文件本身的内容。|blockquote|2959064|2959065|2959066|quote+link|offset|length|2959067|entityMap|0|LINK|mutability|MUTABLE|url|http://www.linuxhowtos.org/System/Linux%2520Memory%2520Management.htm^0|0|0|0|0|0|A|0|0^^$0|@$1|2|3|-4|4|5|6|R|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|S|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|T|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|U|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|V|7|@]|8|@$H|W|I|X|1|Y]]|9|$]]|$1|J|3|-4|4|5|6|Z|7|@]|8|@]|9|$]]]|K|$L|$4|M|N|O|9|$P|Q]]]]

<blockquote>
 Buffers are associated with a specific block device, and cover caching
 of filesystem metadata as well as tracking in-flight pages. The cache
 only contains parked file data. That is, the buffers remember what's
 in directories, what file permissions are, and keep track of what
 memory is being written from or read to for a particular block device.
 The cache only contains the contents of the files themselves.
</blockquote>

<a href="http://www.linuxhowtos.org/System/Linux%20Memory%20Management.htm" rel="noreferrer">quote link</a>

blocks|key|3172972|text|Cited+answer+(for+reference):|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3172973|3172974|简短回答:+Cached是页面缓存的大小。buffers是内存块I/O缓冲区的大小。缓存问题；缓冲区在很大程度上是无关紧要的。|blockquote|3172975|3172976|长期答案:+Cached是Linux页面缓存的大小，减去交换缓存中的内存，用SwapCached表示(因此总的页面缓存大小是Cached+%2B+SwapCached)。Linux通过页面缓存执行所有文件I/O。只需将页缓存中相应的页标记为脏，就可以实现写操作；然后，刷新线程会定期将任何脏页写回磁盘。读取是通过从页面缓存返回数据来实现的；如果数据还不在缓存中，则首先填充该数据。在现代Linux系统上，缓存很容易达到几千兆字节。它只会在内存压力的情况下收缩。系统将清除页面缓存，并将数据交换到磁盘，以便根据需要提供更多内存。|3172977|缓冲区是内存中的块I/O缓冲区。它们的寿命相对较短。在Linux内核2.4版之前，Linux有单独的页缓存和缓冲区缓存。从2.4开始，页面缓存和缓冲区缓存是统一的，并且缓冲区是未在页面缓存中表示的原始磁盘块，即不是文件数据。因此，缓冲区度量是最不重要的。在大多数系统上，缓冲区通常只有几十兆字节。|3172978|entityMap|0|LINK|mutability|MUTABLE|url|http://www.quora.com/What-is-the-difference-between-Buffers-and-Cached-columns-in-proc-meminfo-output^0|0|T|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|Z|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

<a href="http://www.quora.com/What-is-the-difference-between-Buffers-and-Cached-columns-in-proc-meminfo-output" rel="noreferrer">Cited answer (for reference):</a>
<blockquote>
Short answer: Cached is the size of the page cache. Buffers is the size of in-memory block I/O buffers. Cached matters; Buffers is largely irrelevant.
Long answer: Cached is the size of the Linux page cache, minus the memory in the swap cache, which is represented by SwapCached (thus the total page cache size is Cached + SwapCached). Linux performs all file I/O through the page cache. Writes are implemented as simply marking as dirty the corresponding pages in the page cache; the flusher threads then periodically write back to disk any dirty pages. Reads are implemented by returning the data from the page cache; if the data is not yet in the cache, it is first populated. On a modern Linux system, Cached can easily be several gigabytes. It will shrink only in response to memory pressure. The system will purge the page cache along with swapping data out to disk to make available more memory as needed.
Buffers are in-memory block I/O buffers. They are relatively short-lived. Prior to Linux kernel version 2.4, Linux had separate page and buffer caches. Since 2.4, the page and buffer cache are unified and Buffers is raw disk blocks not represented in the page cache—i.e., not file data. The Buffers metric is thus of minimal importance. On most systems, Buffers is often only tens of megabytes.
</blockquote>

blocks|key|2959132|text|它并不像这样简单，但它可能有助于理解：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2959133|Buffer用于存储文件元数据(权限、位置等)。每一个内存页都被记录在这里。|2959134|缓存用于存储实际的文件内容。|2959135|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's not 'quite' as simple as this, but it might help understand:

Buffer is for storing file metadata (permissions, location, etc). Every memory page is kept track of here.

Cache is for storing actual file contents.

blocks|key|2959174|text|我认为这一页将有助于深入理解buffer和cache之间的区别。http://www.tldp.org/LDP/sag/html/buffer-cache.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2959175|与访问(真实)内存相比，从磁盘读取数据非常慢。此外，在相对较短的时间内多次读取磁盘的同一部分是很常见的。例如，人们可能首先阅读一封电子邮件，然后在回复时在编辑器中阅读该信件，然后在将其复制到文件夹时使邮件程序再次阅读该信件。或者，考虑在具有多个用户的系统上运行命令ls的频率。只需从磁盘读取一次信息，然后将其保存在内存中，直到不再需要它，就可以加快除第一次读取之外的所有读取速度。这称为磁盘缓冲，用于此目的的内存称为缓冲区缓存。|style|CODE|2959176|不幸的是，由于内存是一种有限的、不是稀缺的资源，缓冲区缓存通常不会足够大(它不能容纳所有想要使用的数据)。当缓存填满时，最长时间未使用的数据将被丢弃，从而释放的内存将用于新数据。|2959177|磁盘缓冲也适用于写入。一方面，写入的数据通常很快就会被再次读取(例如，将源代码文件保存到文件中，然后由编译器读取)，因此将写入的数据放入缓存中是一个好主意。另一方面，通过只将数据放入高速缓存，而不是立即将其写入磁盘，写入的程序运行得更快。然后可以在后台完成写入，而不会减慢其他程序的运行速度。|2959178|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tldp.org/LDP/sag/html/buffer-cache.html^0|W|1E|0|0|3O|2|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@$A|Y|B|Z|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]]]

I think this page will help understanding the difference between buffer and cache deeply. <a href="http://www.tldp.org/LDP/sag/html/buffer-cache.html" rel="noreferrer">http://www.tldp.org/LDP/sag/html/buffer-cache.html</a>

Reading from a disk is very slow compared to accessing (real) memory. In addition, it is common to read the same part of a disk several times during relatively short periods of time. For example, one might first read an e-mail message, then read the letter into an editor when replying to it, then make the mail program read it again when copying it to a folder. Or, consider how often the command <code>ls</code> might be run on a system with many users. By reading the information from disk only once and then keeping it in memory until no longer needed, one can speed up all but the first read. This is called disk buffering, and the memory used for the purpose is called the buffer cache.

Since memory is, unfortunately, a finite, nay, scarce resource, the buffer cache usually cannot be big enough (it can't hold all the data one ever wants to use). When the cache fills up, the data that has been unused for the longest time is discarded and the memory thus freed is used for the new data.

Disk buffering works for writes as well. On the one hand, data that is written is often soon read again (e.g., a source code file is saved to a file, then read by the compiler), so putting data that is written in the cache is a good idea. On the other hand, by only putting the data into the cache, not writing it to disk at once, the program that writes runs quicker. The writes can then be done in the background, without slowing down the other programs.

blocks|key|266526|text|缓冲区包含有助于提高写入性能的元数据|type|unstyled|depth|inlineStyleRanges|entityRanges|data|266527|缓存包含文件内容本身(有时尚未写入磁盘)，可提高读取性能|266528|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Buffer contains metadata which helps improve write performance

Cache contains the file content itself (sometimes yet to write to disk) which improves read performance

blocks|key|3173070|text|Seth+Robertson的链接2说：“要彻底理解这些术语，请参考Linux内核书籍，如Robert+M.Love的Linux+kernel+Development。”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3173071|我在这本书的第二版中找到了一些关于“buffer”的内容。|3173072|3173073|虽然物理设备本身在扇区级别是可寻址的，但内核以块为单位执行所有磁盘操作。|blockquote|3173074|3173075|当数据块存储在内存中时(例如，在读取或挂起写入之后)，它被存储在“缓冲区”中。每个“缓冲区”恰好与一个块相关联。“buffer”用作表示内存中的磁盘块的对象。|3173076|“缓冲区”是单个物理磁盘块的内存中表示。|3173077|数据块I/O操作一次操作一个磁盘块。一种常见的块I/O操作是读取和写入inode。内核提供面包()函数，以执行从磁盘读取单个块的低级操作。通过“buffers”，磁盘块被映射到它们关联的内存中页面。"|3173078|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Seth Robertson's Link 2 said &quot;For thorough understanding of those terms, refer to Linux kernel book like Linux Kernel Development by Robert M. Love.&quot;
I found some contents about 'buffer' in the 2nd edition of the book.
<blockquote>
Although the physical device itself is addressable at the sector level, the kernel performs all disk operations in terms of blocks.
When a block is stored in memory (say, after a read or pending a write), it is stored in a 'buffer'. Each 'buffer' is associated with exactly one block. The 'buffer' serves as the object that represents a disk block in memory.
A 'buffer' is the in-memory representation of a single physical disk block.
Block I/O operations manipulate a single disk block at a time. A common block I/O operation is reading and writing inodes. The kernel provides the bread() function to perform a low-level read of a single block from disk. Via 'buffers', disk blocks are mapped to their associated in-memory pages. &quot;
</blockquote>

blocks|key|262930|text|由Red+解释|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|262931|缓存页：|262932|缓存是内存的一部分，它透明地存储数据，以便将来对该数据的请求可以更快地得到服务。内核利用该内存来缓存磁盘数据并提高i/o性能。|262933|Linux内核的构建方式是，它将使用尽可能多的RAM来缓存来自本地和远程文件系统和磁盘的信息。随着时间的推移，在系统上执行各种读和写操作，内核试图保留存储在内存中的数据，用于在系统上运行的各种进程，或者保存在不久的将来将使用的相关进程的数据。当进程停止/退出时，缓存不会被回收，但是当其他进程需要比可用内存更多的内存时，内核将运行启发式方法，通过存储缓存数据并将该内存分配给新进程来回收内存。|262934|当请求任何类型的文件/数据时，内核将查找用户正在操作的文件部分的副本，并且如果不存在这样的副本，则它将分配一个新的高速缓冲存储器页面，并用从磁盘读出的适当内容填充它。|262935|存储在高速缓存中的数据可以是早先计算的值，也可以是存储在磁盘中其他地方的原始值的副本。当请求某些数据时，首先检查缓存以查看它是否包含该数据。从缓存中检索数据的速度比从其源来源检索数据的速度更快。|262936|SysV共享内存段也被视为缓存，尽管它们不代表磁盘上的任何数据。可以使用ipcs+-m命令和检查字节列来检查共享内存段的大小。|262937|缓冲区：|262938|缓冲区是存储在页缓存下的数据的磁盘块表示。Buffers包含驻留在页面缓存下的文件/数据的元数据。例如:当存在对页面缓存中存在的任何数据的请求时，内核首先检查缓冲区中的数据，该缓冲区包含指向页面缓存中包含的实际文件/数据的元数据。一旦从元数据获知了文件的实际块地址，内核就会拾取该文件进行处理。|262939|entityMap^0|1|4|0|0|4|0|0|0|0|0|0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|13|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|14|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|15|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|16|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|17|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|1B|8|@]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|W|$]]

Explained by Red Hat:
Cache Pages:
A cache is the part of the memory which transparently stores data so that future requests for that data can be served faster. This memory is utilized by the kernel to cache disk data and improve i/o performance.
The Linux kernel is built in such a way that it will use as much RAM as it can to cache information from your local and remote filesystems and disks. As the time passes over various reads and writes are performed on the system, kernel tries to keep data stored in the memory for the various processes which are running on the system or the data that of relevant processes which would be used in the near future. The cache is not reclaimed at the time when process get stop/exit, however when the other processes requires more memory then the free available memory, kernel will run heuristics to reclaim the memory by storing the cache data and allocating that memory to new process.
When any kind of file/data is requested then the kernel will look for a copy of the part of the file the user is acting on, and, if no such copy exists, it will allocate one new page of cache memory and fill it with the appropriate contents read out from the disk.
The data that is stored within a cache might be values that have been computed earlier or duplicates of original values that are stored elsewhere in the disk. When some data is requested, the cache is first checked to see whether it contains that data. The data can be retrieved more quickly from the cache than from its source origin.
SysV shared memory segments are also accounted as a cache, though they do not represent any data on the disks. One can check the size of the shared memory segments using ipcs -m command and checking the bytes column.
Buffers:
Buffers are the disk block representation of the data that is stored under the page caches. Buffers contains the metadata of the files/data which resides under the page cache.
Example: When there is a request of any data which is present in the page cache, first the kernel checks the data in the buffers which contain the metadata which points to the actual files/data contained in the page caches. Once from the metadata the actual block address of the file is known, it is picked up by the kernel for processing.

blocks|key|266552|text|引用自本书：Introduction+to+Information+Retrieval|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|266553|缓存|style|BOLD|266554|266555|我们希望在内存中保留尽可能多的数据，特别是那些我们需要频繁访问的数据。我们称之为将频繁使用的磁盘数据保存在内存缓存中的技术。|blockquote|266556|266557|266558|缓冲区|266559|266560|操作系统通常读取和写入整个块。因此，从磁盘读取单个字节所需的时间与读取整个块的时间一样长。块大小通常为8、16、32和64千字节(KB)。我们把正在读或写的块存储在主存储器中的那部分称为缓冲区。|266561|266562|entityMap|0|LINK|mutability|MUTABLE|url|https://rads.stackoverflow.com/amzn/click/com/0521865719^0|6|11|0|0|0|2|0|0|0|0|0|0|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@$A|16|B|17|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|I|3|J|5|K|7|19|8|@]|9|@]|C|$]]|$1|L|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1C|8|@$A|1D|B|1E|F|G]]|9|@]|C|$]]|$1|P|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]|$1|Q|3|R|5|K|7|1G|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]|$1|T|3|-4|5|6|7|1I|8|@]|9|@]|C|$]]]|U|$V|$5|W|X|Y|C|$Z|10]]]]

Quote from the book:
<a href="https://rads.stackoverflow.com/amzn/click/com/0521865719" rel="nofollow noreferrer" rel="nofollow noreferrer">Introduction to Information Retrieval</a>

Cache

<blockquote>
 We want to keep as much data as possible in memory, especially those data that we need to access frequently. We call the technique of keeping frequently used disk data in main memory caching.
</blockquote>

Buffer

<blockquote>
 Operating systems generally read and write entire blocks. Thus, reading a single byte from disk can take as much time as reading the entire block. Block sizes of 8, 16, 32, and 64 kilobytes (KB) are common. We call the part of main memory where a block being read or written is stored a buffer.
</blockquote>

blocks|key|2959296|text|Cache:这是内核在物理RAM上获取的位置，用于在缓存中存储页面。现在我们需要某种类型的索引来从缓存中获取页面的地址。这里我们需要用于页面缓存的缓冲区，它保存页面缓存的元数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2959297|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Cache: This is a place acquired by kernel on physical RAM to store pages in caches. Now we need some sort of index to get the address of pages from caches. Here we need the buffer for page caches which keeps metadata of page cache.

To me it's not clear what's the difference between the two Linux memory concepts : <code>buffer</code> and <code>cache</code>. I've read through <a href="https://stackoverflow.com/questions/3192579/buffer-and-cache-difference">this post</a> and it seems to me that the difference between them is the expiration policy:
<ol>
<li>buffer's policy is first-in, first-out</li>
<li>cache's policy is Least Recently Used.</li>
</ol>
Am I right?
In particular, I'm looking at the two commands: <code>free</code> and <code>vmstat</code>
<pre><code>james@utopia:~$ vmstat -S M
procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
r b swpd free buff cache si so bi bo in cs us sy id wa
5 0 0 173 67 912 0 0 19 59 75 1087 24 4 71 1
james@utopia:~$ free -m
 total used free shared buffers cached
Mem: 2007 1834 172 0 67 914
-/+ buffers/cache: 853 1153
Swap: 2859 0 2859
</code></pre>

What is the difference between buffer and cache memory in Linux?

数据块存储

数据存储

文件系统

编译器

Linux

对我来说，不清楚buffer和cache这两个Linux内存概念之间的区别。我通读了一下，在我看来，它们之间的区别在于过期策略：first-outcache's buffer的策略是先入，最近最少使用策略。我说的对吗？特别是，我正在研究两个命令：free和vmstatjames@utopia:~$ vmstat -S ...

问Linux中的缓冲区和缓存有什么不同？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Linux中的缓冲区和缓存有什么不同？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Linux中的缓冲区和缓存有什么不同？
EN