如何排查MacOS多线程C++程序的堆争用耗时占比？

嘿，这个问题我太熟了——堆争用在多线程C++场景里简直是隐形的性能杀手，尤其是MacOS默认的libmalloc实现，在高并发频繁分配/释放小对象时，锁竞争会拖慢整个程序。你说拆分进程后速度更快，这完全符合堆争用的特征（进程有独立堆，不存在跨进程的堆锁竞争）。下面给你几个靠谱的方法，精准统计线程因堆争用浪费的时间：

这是MacOS上最易用的性能分析工具，能直观看到线程的阻塞时间和堆调用的关联：

• 打开Instruments，选择Locks and Threads模板，要么附加到已经运行的程序，要么直接通过Instruments启动你的C++程序。
• 让程序运行一段时间后停止录制，先看左侧的线程状态追踪：重点关注每个线程的Blocked状态，其中Mutex Wait或Semaphore Wait的时间，很大一部分就是堆分配锁带来的浪费。
• 切换到Call Tree视图，勾选下方的「Invert Call Tree」和「Hide System Libraries」（或者不隐藏，直接找malloc/operator new/free这些函数），查看这些函数的Self Wait Time和Total Wait Time——这两个数值就是堆操作时因为锁争用消耗的时间，占总运行时间的比例越高，堆争用越严重。
• 额外推荐Malloc模板：它能统计每个线程的堆分配次数、对象大小分布，帮你定位哪些线程在疯狂调用分配函数，从源头找到争用的热点。

dtrace是MacOS底层的动态追踪神器，能精准捕捉堆锁的等待时间，不需要修改代码：

• 先写一个简单的dtrace脚本（比如命名为heap_wait.d），统计malloc调用的总耗时（包含锁等待）：

pid$target::malloc:entry
{
    self->start_ts = timestamp;
}

pid$target::malloc:return
/self->start_ts/
{
    this->elapsed = timestamp - self->start_ts;
    @total_wait["malloc总等待时间(ns)"] = sum(this->elapsed);
    @call_count["malloc调用次数"] = count();
    self->start_ts = 0;
}

tick-5s
{
    printa(@total_wait);
    printa(@call_count);
    trunc(@total_wait);
    trunc(@call_count);
}

• 运行方式：要么附加到运行中的程序sudo dtrace -s heap_wait.d -p <你的程序PID>，要么直接启动程序sudo dtrace -s heap_wait.d -c "./your_cpp_program"。每5秒会输出一次统计结果，你可以换算成平均每次分配的等待时间，或者和程序总运行时间对比，得到争用时间的占比。
• 如果要更精准地追踪堆锁本身，可以针对libmalloc内部的malloc_mutex_lock函数写脚本：

pid$target::malloc_mutex_lock:entry
{
    self->lock_start = timestamp;
}

pid$target::malloc_mutex_lock:return
/self->lock_start/
{
    this->lock_elapsed = timestamp - self->lock_start;
    @lock_total["堆锁总等待时间(ns)"] = sum(this->lock_elapsed);
    self->lock_start = 0;
}

这个脚本直接统计堆分配时锁的等待时间，结果更精准。

如果需要针对特定线程或代码块做统计，可以自己封装分配函数，结合线程本地存储记录耗时：

#include <chrono>
#include <thread>
#include <unordered_map>
#include <mutex>
#include <cstdio>

// 线程本地存储：记录当前线程的堆操作总耗时
thread_local std::chrono::nanoseconds thread_heap_wait{0};
// 全局统计：存储所有线程的耗时数据
std::unordered_map<std::thread::id, std::chrono::nanoseconds> global_heap_stats;
std::mutex stats_mutex;

// 重载operator new
void* operator new(size_t size) {
    auto start = std::chrono::high_resolution_clock::now();
    void* ptr = std::malloc(size);
    auto end = std::chrono::high_resolution_clock::now();
    thread_heap_wait += end - start;
    return ptr;
}

// 重载operator delete
void operator delete(void* ptr) noexcept {
    auto start = std::chrono::high_resolution_clock::now();
    std::free(ptr);
    auto end = std::chrono::high_resolution_clock::now();
    thread_heap_wait += end - start;
}

// 程序退出时输出所有线程的统计结果
void print_heap_stats() {
    std::lock_guard<std::mutex> lock(stats_mutex);
    global_heap_stats[std::this_thread::get_id()] = thread_heap_wait;
    
    printf("=== 堆操作耗时统计 ===\n");
    for (const auto& [tid, time] : global_heap_stats) {
        printf("线程ID: %p | 总耗时: %lld ns | 约%.2f ms\n",
               tid, time.count(), time.count() / 1000000.0);
    }
}

// 注册退出函数，程序结束时自动打印统计
static auto register_stats_printer = [](){
    std::atexit(print_heap_stats);
    return 0;
}();

• 注意：这种方法统计的是堆操作的总耗时（包含正常分配/释放时间+锁等待时间），如果你的程序堆争用严重，这部分耗时会远高于无争用的情况，能间接反映问题。如果需要区分锁等待和正常执行时间，可以结合dtrace的结果来校准。

• 替换分配器：试试把默认的libmalloc换成tcmalloc或jemalloc（这俩都是为多线程优化的分配器），如果替换后程序速度明显提升，那基本实锤是堆争用。对比替换前后的运行时间，差值就是原来堆争用浪费的时间。
• 查看堆分布：用vmmap <你的程序PID>命令，看看是否有大量小对象分配——这类场景是堆锁争用的重灾区，也是优化的重点。

内容的提问来源于stack exchange，提问作者kdog