内存碎片是因为请求不同大小的内存块。考虑一个100字节的缓冲区。您请求两个字符，然后是一个整数。现在释放这两个字符，然后请求一个新的整数——但是这个整数不能容纳这两个字符的空间。该内存不能被重用，因为它不在一个足够大的连续块中，无法重新分配。除此之外，还为字符调用了大量分配器开销。

从本质上讲，在大多数系统上，内存只以一定大小的块形式存在。一旦你把这些块分开，它们不能重新连接，直到整个块被释放。这可能导致整个区块都在使用，而实际上只有一小部分区块在使用。

The primary way to reduce heap fragmentation is to make larger, less frequent allocations. In the extreme, you can use a managed heap that is capable of moving objects, at least, within your own code. This completely eliminates the problem - from a memory perspective, anyway. Obviously moving objects and such has a cost. In reality, you only really have a problem if you are allocating very small amounts off the heap often. Using contiguous containers (vector, string, etc) and allocating on the stack as much as humanly possible (always a good idea for performance) is the best way to reduce it. This also increases cache coherence, which makes your application run faster.

您应该记住的是，在一个32位x86桌面系统上，您有一个完整的2GB内存，它被分割成4KB的“页”(非常确定所有x86系统上的页大小是相同的)。您将不得不调用一些omgwtfbbq片段来解决问题。碎片确实是过去的一个问题，因为现代堆对于绝大多数应用程序来说都太大了，而且有一些流行的系统能够承受它，比如托管堆。

这是一个超级简化版的傻瓜。

当对象在内存中创建时，它们被添加到内存中已使用部分的末尾。

如果一个对象不在已使用内存部分的末尾被删除，这意味着这个对象位于其他两个对象之间，它将创建一个“洞”。

这就是所谓的碎片化。

什么是内存碎片?

Memory fragmentation is the problem of memory becoming unusable even though it is theoretically available. There are two kinds of fragmentation: internal fragmentation is memory that is allocated but cannot be used (e.g. when memory is allocated in 8 byte chunks but the program repeatedly does single allocations when it needs only 4 bytes). external fragmentation is the problem of free memory becoming divided into many small chunks so that large allocation requests cannot be met although there is enough overall free memory.

如何判断内存碎片是否是我的应用程序的一个问题?什么样的程序最可能受到影响?

如果您的程序使用的系统内存远远超过其实际有效负载数据所需的内存(并且您已经排除了内存泄漏)，那么内存碎片就是一个问题。

处理内存碎片的常用方法是什么?

使用一个好的内存分配器。在IIRC中，那些使用“最佳匹配”策略的人通常在避免碎片化方面要出色得多，只是速度稍慢一些。然而，事实也表明，对于任何配置策略，都存在病态的最坏情况。幸运的是，对于分配器来说，大多数应用程序的典型分配模式实际上是相对友好的。如果你对细节感兴趣，这里有一堆文件:

Paul R. Wilson, Mark S. Johnstone, Michael Neely and David Boles. Dynamic Storage Allocation: A Survey and Critical Review. In Proceedings of the 1995 International Workshop on Memory Management, Springer Verlag LNCS, 1995 Mark S.Johnstone, Paul R. Wilson. The Memory Fragmentation Problem: Solved? In ACM SIG-PLAN Notices, volume 34 No. 3, pages 26-36, 1999 M.R. Garey, R.L. Graham and J.D. Ullman. Worst-Case analysis of memory allocation algorithms. In Fourth Annual ACM Symposium on the Theory of Computing, 1972

什么是内存碎片?

When your app uses dynamic memory, it allocates and frees chunks of memory. In the beginning, the whole memory space of your app is one contiguous block of free memory. However, when you allocate and free blocks of different size, the memory starts to get fragmented, i.e. instead of a big contiguous free block and a number of contiguous allocated blocks, there will be a allocated and free blocks mixed up. Since the free blocks have limited size, it is difficult to reuse them. E.g. you may have 1000 bytes of free memory, but can't allocate memory for a 100 byte block, because all the free blocks are at most 50 bytes long.

另一个不可避免但问题较少的碎片来源是，在大多数架构中，内存地址必须对齐到2,4,8等字节边界(即地址必须是2,4,8的倍数等)这意味着，即使你有一个包含3个char字段的结构，你的结构可能有12而不是3，因为每个字段都对齐到4字节边界。

如何判断内存碎片是否是我的应用程序的一个问题?什么样的程序最可能受到影响?

最明显的答案是内存不足异常。

显然，在c++应用程序中，没有一种好的便携式方法来检测内存碎片。更多细节请看这个答案。

处理内存碎片的常用方法是什么?

这在c++中很困难，因为你在指针中使用直接内存地址，你无法控制谁引用特定的内存地址。因此，重新安排已分配的内存块(Java垃圾收集器的方式)是不可取的。

自定义分配器可以通过在较大内存块中管理小对象的分配，并重用该块中的空闲插槽来提供帮助。

内存碎片是因为请求不同大小的内存块。考虑一个100字节的缓冲区。您请求两个字符，然后是一个整数。现在释放这两个字符，然后请求一个新的整数——但是这个整数不能容纳这两个字符的空间。该内存不能被重用，因为它不在一个足够大的连续块中，无法重新分配。除此之外，还为字符调用了大量分配器开销。

从本质上讲，在大多数系统上，内存只以一定大小的块形式存在。一旦你把这些块分开，它们不能重新连接，直到整个块被释放。这可能导致整个区块都在使用，而实际上只有一小部分区块在使用。

The primary way to reduce heap fragmentation is to make larger, less frequent allocations. In the extreme, you can use a managed heap that is capable of moving objects, at least, within your own code. This completely eliminates the problem - from a memory perspective, anyway. Obviously moving objects and such has a cost. In reality, you only really have a problem if you are allocating very small amounts off the heap often. Using contiguous containers (vector, string, etc) and allocating on the stack as much as humanly possible (always a good idea for performance) is the best way to reduce it. This also increases cache coherence, which makes your application run faster.

您应该记住的是，在一个32位x86桌面系统上，您有一个完整的2GB内存，它被分割成4KB的“页”(非常确定所有x86系统上的页大小是相同的)。您将不得不调用一些omgwtfbbq片段来解决问题。碎片确实是过去的一个问题，因为现代堆对于绝大多数应用程序来说都太大了，而且有一些流行的系统能够承受它，比如托管堆。

当分配和释放许多大小不同的对象时，最可能发生内存碎片。假设你在内存中有如下布局:

obj1 (10kb) | obj2(20kb) | obj3(5kb) | unused space (100kb)

现在，当obj2被释放时，您有120kb的未使用内存，但是您不能分配120kb的完整块，因为内存是碎片化的。

避免这种影响的常用技术包括环形缓冲区和对象池。在STL的上下文中，像std::vector::reserve()这样的方法可以提供帮助。