C++ 中排查内存泄漏和死锁的详细步骤

以下是在 C++ 中排查内存泄漏和死锁的详细步骤：

一、内存泄漏排查

（一）使用工具

1. Valgrind：
   • 步骤：
     • 安装 Valgrind（适用于 Linux 系统）。
     • 编译程序时使用 -g 选项添加调试信息，例如：

g++ -g -o my_program my_program.cpp

    - 使用 Valgrind 的 `memcheck` 工具运行程序：

valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes./my_program

• 输出解释：
  • Invalid read/write：表明程序正在尝试读取或写入无效的内存地址，这可能是内存泄漏的一个迹象。
  • Definitely lost：表示程序中存在明确的内存泄漏，这些内存块没有被释放，且没有指针指向它们。
  • Indirectly lost：表明有一些内存块虽然有指针指向，但这些指针所指向的内存块已经泄漏，导致这些内存块间接泄漏。
  • Possible lost：表示内存块可能已经泄漏，但无法确定，可能是由于复杂的指针操作导致的。
  • Still reachable：表明程序正常结束时仍然可达的内存，可能是因为全局变量或静态变量等，通常不是严重问题，但可能需要关注。

2. AddressSanitizer（ASan）：
   • 步骤：
     • 编译时使用 -fsanitize=address 选项，例如：

g++ -fsanitize=address -g -o my_program my_program.cpp

    - 运行程序：

./my_program

• 输出解释：
  • ASan 会输出内存错误的详细信息，包括错误类型（如堆缓冲区溢出、栈缓冲区溢出、内存泄漏等）、错误发生的位置（文件和行号）以及堆栈跟踪，帮助定位问题。

（二）手动检查

1. 使用智能指针：
   • 尽量使用 std::unique_ptr、std::shared_ptr 和 std::weak_ptr 等智能指针来管理动态内存，它们会自动释放内存，避免手动调用 delete 时忘记释放或多次释放的问题。

#include 
void func() {
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    // 无需调用 delete，ptr 离开作用域时会自动释放内存
}

2. 记录分配和释放：
   • 可以创建一个自定义的内存分配器或重载 new 和 delete 运算符，在分配和释放内存时进行记录，这样可以帮助你追踪内存的使用情况。

#include 
#include 
#include 

std::unordered_map<void*, size_t> memory_map;

void* operator new(size_t size) {
    void* ptr = std::malloc(size);
    memory_map[ptr] = size;
    return ptr;
}

void operator delete(void* ptr) noexcept {
    if (memory_map.count(ptr)) {
        memory_map.erase(ptr);
    }
    std::free(ptr);
}

int main() {
    int* ptr = new int(10);
    delete ptr;
    for (const auto& [ptr, size] : memory_map) {
        std::cout << "Memory at " << ptr << " of size " << size << " not deleted." << std::endl;
    }
    return 0;
}

二、死锁排查

（一）使用工具

1. Helgrind（Valgrind 的一部分）：
   • 步骤：
     • 编译程序时添加 -g 选项添加调试信息。
     • 使用 Valgrind 的 helgrind 工具运行程序：

valgrind --tool=helgrind./my_program

- **输出解释**：
    - Helgrind 会输出可能导致死锁的互斥锁操作，包括锁的获取和释放顺序、可能的竞争条件和死锁位置。它会指出哪些线程在哪些位置获取和释放锁，以及可能的锁顺序错误。

2. GDB（GNU 调试器）：
   • 步骤：
     • 编译程序时添加 -g 选项添加调试信息。
     • 启动 GDB 并运行程序：

g++ -g -o my_program my_program.cpp
gdb./my_program

• 在 GDB 中设置断点、观察变量、检查线程状态等，使用 info threads 查看线程信息，使用 thread 切换到特定线程，使用 bt 查看线程的调用栈。
  • 检查互斥锁的状态，查看哪些线程持有锁，哪些线程在等待锁。
• 使用示例：

(gdb) run
(gdb) info threads
(gdb) thread 2
(gdb) bt

（二）手动检查

1. 检查锁的使用顺序：
   • 确保所有线程以相同的顺序获取多个锁，避免锁的循环等待。例如，如果线程 A 先获取锁 lock1 再获取 lock2，那么其他线程也应该遵循相同的顺序，否则可能导致死锁。

#include 
#include 
#include 

std::mutex lock1;
std::mutex lock2;

void threadFunction1() {
    std::lock_guard<std::mutex> guard1(lock1);
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟工作
    std::lock_guard<std::mutex> guard2(lock2);
    std::cout << "Thread 1 finished." << std::endl;
}

void threadFunction2() {
    std::lock_guard<std::mutex> guard1(lock2); // 错误：顺序不同
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟工作
    std::lock_guard<std::mutex> guard2(lock1); // 错误：顺序不同
    std::cout << "Thread 2 finished." << std::endl;
}

int main() {
    std::thread t1(threadFunction1);
    std::thread t2(threadFunction2);
    t1.join();
    t2.join();
    return 0;
}

2. 避免嵌套锁：
   • 尽量减少嵌套锁的使用，尤其是在复杂的代码中。如果必须使用嵌套锁，确保正确的锁定顺序，并考虑使用 std::scoped_lock （C++17 及以上），它可以同时锁定多个锁，避免死锁。

#include 
#include 
#include 
#include 

std::mutex lock1;
std::mutex lock2;

void threadFunction1() {
    std::scoped_lock<std::mutex, std::mutex> guard(lock1, lock2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟工作
    std::cout << "Thread 1 finished." << std::endl;
}

void threadFunction2() {
    std::scoped_lock<std::mutex, std::mutex> guard(lock1, lock2);
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟工作
    std::cout << "Thread 2 finished." << std::endl;
}

int main() {
    std::thread t1(threadFunction1);
    std::thread t2(threadFunction2);
    t1.join();
    t2.join();
    return 0;
}

3. 超时机制：
   • 对于 std::mutex，可以使用 std::timed_mutex 和 try_lock_for 或 try_lock_until 函数添加超时机制，避免无限期等待。

#include 
#include 
#include 
#include 

std::timed_mutex mtx;

void threadFunction() {
    if (mtx.try_lock_for(std::chrono::milliseconds(100)) {
        try {
            std::cout << "Lock acquired." << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
        } catch (...) {
            mtx.unlock();
        }
        mtx.unlock();
    } else {
        std::cout << "Failed to acquire lock." << std::endl;
    }
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);
    t1.join();
    t2.join();
    return 0;
}

通过上述工具和手动检查的方法，可以有效地排查 C++ 程序中的内存泄漏和死锁问题。在实际开发中，应该养成良好的编程习惯，合理使用内存管理工具和并发控制机制，以避免这些问题的发生。同时，使用工具时要仔细分析输出结果，找出问题的根源并进行修复。