这是一个经验假设(分配比取消分配更快)。

这也是一个的原因，我猜，为什么基于堆的存储(如STL容器或其他)选择不将当前未使用的内存返回给系统(这就是 shrink-to-fit 习语诞生的原因。

当然，我们不应该将“堆”内存与类似“堆”的数据结构混淆。

那么为什么取消分配速度较慢？

它是 Windows 特定的(我在 Win 8.1 上看到它)还是独立于 OS？

是否有一些 C++ 特定的内存管理器自动参与使用“new”/“delete”或整个内存。管理完全依赖于操作系统？ (我知道 C++11 引入了一些垃圾收集支持，我从来没有真正使用过，最好依赖旧的 stack 和 static duration或 self 管理的容器和RAII)。

此外，在 FOLLY string 的代码中，我看到使用旧的 C 堆分配/释放，它是否比 C++ 'new'/'delete 更快'?

P. S. 请注意，问题不是关于虚拟内存机制，我知道用户空间程序没有使用真正的内存。地址。

最佳答案

分配内存比释放内存更快的断言对我来说有点奇怪，所以我测试了它。我运行了一个测试，我在 32 字节 block 中分配了 64MB 内存(因此对 new 进行了 2M 次调用)，然后我尝试按照分配的相同顺序删除该内存，并且是随机顺序。我发现线性顺序解除分配比分配快大约 3%，而随机解除分配比线性分配慢大约 10%。

然后我运行了一个测试，从 64MB 的分配内存开始，然后 2M 次分配新内存或删除现有内存(随机)。在这里，我发现释放比分配慢 4.3%。

所以，事实证明你是对的——释放比分配慢(尽管我不会称它“慢很多”)。我怀疑这与更多的随机访问有关，但除了线性释放速度更快之外，我没有其他证据证明这一点。

回答您的一些问题:

是否有一些特定于 C++ 的内存管理器自动参与使用“新建”/“删除”？

是的。操作系统具有将内存页(通常为 4KB block )分配给进程的系统调用。将这些页面划分为对象是进程的工作。尝试查找“GNU 内存分配器”。

我看到使用旧的 C 堆分配/释放，它比 C++“新建”/“删除”更快吗？

大多数 C++ new/delete 实现只是在后台调用 malloc 和 free。然而，标准并不要求这样做，因此最好始终对任何特定对象使用相同的分配和释放函数。

我在 Windows 10 64 位机器上使用 Visual Studio 2015 中提供的 native 测试框架运行了我的测试(测试也是 64 位的)。这是代码:

#include "stdafx.h"
#include "CppUnitTest.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace AllocationSpeedTest
{       
    class Obj32 {
        uint64_t a;
        uint64_t b;
        uint64_t c;
        uint64_t d;
    };
    constexpr int len = 1024 * 1024 * 2;
    Obj32* ptrs[len];
    TEST_CLASS(UnitTest1)
    {
    public:
        TEST_METHOD(Linear32Alloc)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
        }
        TEST_METHOD(Linear32AllocDealloc)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            for (int i = 0; i < len; ++i) {
                delete ptrs[i];
            }
        }
        TEST_METHOD(Random32AllocShuffle)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            srand(0);
            for (int i = 0; i < len; ++i) {
                int pos = (rand() % (len - i)) + i;
                Obj32* temp = ptrs[i];
                ptrs[i] = ptrs[pos];
                ptrs[pos] = temp;
            }
        }
        TEST_METHOD(Random32AllocShuffleDealloc)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            srand(0);
            for (int i = 0; i < len; ++i) {
                int pos = (rand() % (len - i)) + i;
                Obj32* temp = ptrs[i];
                ptrs[i] = ptrs[pos];
                ptrs[pos] = temp;
            }
            for (int i = 0; i < len; ++i) {
                delete ptrs[i];
            }
        }
        TEST_METHOD(Mixed32Both)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            srand(0);
            for (int i = 0; i < len; ++i) {
                if (rand() % 2) {
                    ptrs[i] = new Obj32();
                }
                else {
                    delete ptrs[i];
                }
            }
        }
        TEST_METHOD(Mixed32Alloc)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            srand(0);
            for (int i = 0; i < len; ++i) {
                if (rand() % 2) {
                    ptrs[i] = new Obj32();
                }
                else {
                    //delete ptrs[i];
                }
            }
        }
        TEST_METHOD(Mixed32Dealloc)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            srand(0);
            for (int i = 0; i < len; ++i) {
                if (rand() % 2) {
                    //ptrs[i] = new Obj32();
                }
                else {
                    delete ptrs[i];
                }
            }
        }
        TEST_METHOD(Mixed32Neither)
        {
            for (int i = 0; i < len; ++i) {
                ptrs[i] = new Obj32();
            }
            srand(0);
            for (int i = 0; i < len; ++i) {
                if (rand() % 2) {
                    //ptrs[i] = new Obj32();
                }
                else {
                    //delete ptrs[i];
                }
            }
        }
    };
}

这是多次运行的原始结果。所有数字均以毫秒为单位。

关于c++ - 为什么释放堆内存比分配它慢得多？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38030504/