进程、线程死锁和内存泄漏检测工具-Valgrind

内存泄漏检测

        举例一个包含了内存泄漏的程序，

#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(10 * sizeof(int)); // 分配内存
    // 故意不释放内存，造成内存泄漏
    return 0;
}

        然后GCC编译它，

gcc -g -o leak leak.c

        接下来，使用Valgrind的Memcheck工具来运行这个程序，并检测内存泄漏：

valgrind --leak-check=full ./leak

// --leak-check=full 选项告诉Valgrind进行详细的内存泄漏检查。

        Valgrind的输出将包括关于内存泄漏的详细信息，例如：

==12345== Memcheck, a memory error detector
==12345== Copyright (C) 2002-2015, and GNU GPL“d, by Julian Seward et al.
==12345== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info

#指令
==12345== Command: ./leak
==12345==
==12345== 

//运行对象
--12345-- run: /usr/bin/ld-linux-x86-64.so.2 BUILD_ID=12345 main 0x400480 0x602010
--12345--   obj:/home/user/leak
==12345==    fun:main
==12345==    fun:(below main)

//堆栈摘要
==12345== HEAP SUMMARY:
==12345==     in use at exit: 40 bytes in 1 blocks
==12345==   total heap usage: 1 allocs, 0 frees, 40 bytes allocated
==12345== 

//泄漏摘要
==12345== LEAK SUMMARY:
==12345==    definitely lost: 40 bytes in 1 blocks
==12345==    indirectly lost: 0 bytes in 0 blocks
==12345==      possibly lost: 0 bytes in 0 blocks
==12345==    still reachable: 0 bytes in 0 blocks
==12345==         suppressed: 0 bytes in 0 blocks
==12345== Rerun with --leak-check=full to see details of leaked memory
==12345== 

//可以添加-v参数来重新运行Valgrind，以获取检测到的错误和被抑制的错误的计数
==12345== For counts of detected and suppressed errors, rerun with: -v

//报告了有 1 个错误来自 1个上下文，没有被抑制的错误
==12345== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0)

死锁

        Valgrind的 DRD和 Helgrind工具来检测死锁。DRD 和 Helgrind都是用来检测多线程程序种错误的工具，两者使用不同的分析技术。

        Helgrind能够检测锁顺序违规，例如A线程/进程先获取锁1再获取锁2，B线程/进程先获取锁2再获取锁1，双方各自等对方的锁，这种情况Helgrind可以检测到。

        DRD不提供锁顺序违规的检测功能，更多关注内存数据竞争的问题。

DRD检测死锁

        一个死锁例子

#include <pthread.h>

// 定义两个互斥锁
pthread_mutex_t s_mutex_a;
pthread_mutex_t s_mutex_b;

// 定义一个屏障，用于同步两个线程
pthread_barrier_t s_barrier;

// 定义一个函数，用于尝试锁定两个互斥锁，可能造成死锁
void lock() {
    // 锁定互斥锁s_mutex_b
    pthread_mutex_lock(&s_mutex_b);
    // 等待屏障，确保主线程和子线程都到达这一点后再继续
    pthread_barrier_wait(&s_barrier);
    // 尝试锁定互斥锁s_mutex_a，可能与子线程的锁定顺序冲突
    pthread_mutex_lock(&s_mutex_a);
    // 解锁s_mutex_a
    pthread_mutex_unlock(&s_mutex_a);
    // 解锁s_mutex_b
    pthread_mutex_unlock(&s_mutex_b);
}

// 定义子线程的执行函数
static void* thread_routine(void* arg) {
    // 锁定互斥锁s_mutex_a
    pthread_mutex_lock(&s_mutex_a);
    // 等待屏障，确保主线程和子线程都到达这一点后再继续
    pthread_barrier_wait(&s_barrier);
    // 尝试锁定互斥锁s_mutex_b，可能与主线程的锁定顺序冲突
    pthread_mutex_lock(&s_mutex_b);
    // 解锁s_mutex_b
    pthread_mutex_unlock(&s_mutex_b);
    // 解锁s_mutex_a
    pthread_mutex_unlock(&s_mutex_a);
    return NULL;
}

// 主函数
int main(int argc, char** argv) {
    pthread_t tid;
    // 初始化互斥锁s_mutex_a
    pthread_mutex_init(&s_mutex_a, NULL);
    // 初始化互斥锁s_mutex_b
    pthread_mutex_init(&s_mutex_b, NULL);
    // 初始化屏障，需要两个线程都到达屏障点
    pthread_barrier_init(&s_barrier, NULL, 2);
    // 创建一个子线程，执行thread_routine函数
    pthread_create(&tid, NULL, &thread_routine, NULL);
    // 调用lock函数，尝试锁定两个互斥锁
    lock();
    // 等待子线程结束
    pthread_join(tid, NULL);
    // 销毁屏障
    pthread_barrier_destroy(&s_barrier);
    // 销毁互斥锁s_mutex_a
    pthread_mutex_destroy(&s_mutex_a);
    // 销毁互斥锁s_mutex_b
    pthread_mutex_destroy(&s_mutex_b);
    return 0;
}

        在这个程序中，主线程和子线程分别尝试锁定两个互斥锁，但由于顺序不同，导致了死锁。

        使用DRD检测死锁的命令如下：

valgrind --tool=drd --trace-mutex=yes ./dead_lock

        DRD会输出互斥锁的操作记录，通过分析这些记录可以确定死锁的发生。

==12345== --- drd: a data race detector and thread error detector tool
==12345== Thread 1: lock1 acquired
==12345== Thread 2: lock2 acquired
//检测到死锁
==12345== Potential deadlock detected between lock1 and lock2
==12345== Thread 1:
    at 0x...: pthread_mutex_lock (drd_pthread_intercepts.c:...)
    at 0x...: func1 (deadlock_example.c:...)
==12345== Thread 2:
    at 0x...: pthread_mutex_lock (drd_pthread_intercepts.c:...)
    at 0x...: func2 (deadlock_example.c:...)

Helgrind检测死锁

        编译出可执行程序后使用检测工具：

valgrind --tool=helgrind ./dead_lock

        如果程序发生死锁，Helgrind会输出详细的错误信息，包括发生死锁的线程和代码位置。通常需要使用Ctrl+C来终止程序以查看Helgrind的输出结果。